]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_gdi_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wxCheckListBox doesn't require wxUSE_OWNER_DRAWN when using WXUNIVERSAL
[wxWidgets.git] / wxPython / src / mac / _gdi_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxPostScriptDC swig_types[0]
1343 #define SWIGTYPE_p_wxBrush swig_types[1]
1344 #define SWIGTYPE_p_wxColour swig_types[2]
1345 #define SWIGTYPE_p_wxDC swig_types[3]
1346 #define SWIGTYPE_p_wxMirrorDC swig_types[4]
1347 #define SWIGTYPE_p_form_ops_t swig_types[5]
1348 #define SWIGTYPE_p_wxDuplexMode swig_types[6]
1349 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[7]
1350 #define SWIGTYPE_p_char swig_types[8]
1351 #define SWIGTYPE_p_wxIconLocation swig_types[9]
1352 #define SWIGTYPE_p_wxImage swig_types[10]
1353 #define SWIGTYPE_p_wxMetaFileDC swig_types[11]
1354 #define SWIGTYPE_p_wxMask swig_types[12]
1355 #define SWIGTYPE_p_wxSize swig_types[13]
1356 #define SWIGTYPE_p_wxFont swig_types[14]
1357 #define SWIGTYPE_p_wxWindow swig_types[15]
1358 #define SWIGTYPE_p_double swig_types[16]
1359 #define SWIGTYPE_p_wxMemoryDC swig_types[17]
1360 #define SWIGTYPE_p_wxFontMapper swig_types[18]
1361 #define SWIGTYPE_p_wxEffects swig_types[19]
1362 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[20]
1363 #define SWIGTYPE_p_wxPalette swig_types[21]
1364 #define SWIGTYPE_p_wxBitmap swig_types[22]
1365 #define SWIGTYPE_p_wxObject swig_types[23]
1366 #define SWIGTYPE_p_wxRegionIterator swig_types[24]
1367 #define SWIGTYPE_p_wxRect swig_types[25]
1368 #define SWIGTYPE_p_wxPaperSize swig_types[26]
1369 #define SWIGTYPE_p_wxString swig_types[27]
1370 #define SWIGTYPE_unsigned_int swig_types[28]
1371 #define SWIGTYPE_p_unsigned_int swig_types[29]
1372 #define SWIGTYPE_p_wxPrinterDC swig_types[30]
1373 #define SWIGTYPE_p_wxIconBundle swig_types[31]
1374 #define SWIGTYPE_p_wxPoint swig_types[32]
1375 #define SWIGTYPE_p_wxDash swig_types[33]
1376 #define SWIGTYPE_p_wxScreenDC swig_types[34]
1377 #define SWIGTYPE_p_wxCursor swig_types[35]
1378 #define SWIGTYPE_p_wxClientDC swig_types[36]
1379 #define SWIGTYPE_p_wxBufferedDC swig_types[37]
1380 #define SWIGTYPE_p_wxImageList swig_types[38]
1381 #define SWIGTYPE_p_unsigned_char swig_types[39]
1382 #define SWIGTYPE_p_wxGDIObject swig_types[40]
1383 #define SWIGTYPE_p_wxIcon swig_types[41]
1384 #define SWIGTYPE_p_wxLocale swig_types[42]
1385 #define SWIGTYPE_ptrdiff_t swig_types[43]
1386 #define SWIGTYPE_std__ptrdiff_t swig_types[44]
1387 #define SWIGTYPE_p_wxRegion swig_types[45]
1388 #define SWIGTYPE_p_wxConfigBase swig_types[46]
1389 #define SWIGTYPE_p_wxLanguageInfo swig_types[47]
1390 #define SWIGTYPE_p_wxWindowDC swig_types[48]
1391 #define SWIGTYPE_p_wxPrintData swig_types[49]
1392 #define SWIGTYPE_p_wxBrushList swig_types[50]
1393 #define SWIGTYPE_p_wxFontList swig_types[51]
1394 #define SWIGTYPE_p_wxPen swig_types[52]
1395 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[53]
1396 #define SWIGTYPE_p_wxPaintDC swig_types[54]
1397 #define SWIGTYPE_p_wxPenList swig_types[55]
1398 #define SWIGTYPE_p_int swig_types[56]
1399 #define SWIGTYPE_p_wxMetaFile swig_types[57]
1400 #define SWIGTYPE_p_unsigned_long swig_types[58]
1401 #define SWIGTYPE_p_wxNativeFontInfo swig_types[59]
1402 #define SWIGTYPE_p_wxEncodingConverter swig_types[60]
1403 #define SWIGTYPE_p_wxColourDatabase swig_types[61]
1404 static swig_type_info *swig_types[63];
1405
1406 /* -------- TYPES TABLE (END) -------- */
1407
1408
1409 /*-----------------------------------------------
1410 @(target):= _gdi_.so
1411 ------------------------------------------------*/
1412 #define SWIG_init init_gdi_
1413
1414 #define SWIG_name "_gdi_"
1415
1416 #include "wx/wxPython/wxPython.h"
1417 #include "wx/wxPython/pyclasses.h"
1418
1419
1420 static const wxString wxPyEmptyString(wxEmptyString);
1421
1422 #include <limits.h>
1423
1424
1425 SWIGINTERN int
1426 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1427 const char *errmsg)
1428 {
1429 if (value < min_value) {
1430 if (errmsg) {
1431 PyErr_Format(PyExc_OverflowError,
1432 "value %ld is less than '%s' minimum %ld",
1433 value, errmsg, min_value);
1434 }
1435 return 0;
1436 } else if (value > max_value) {
1437 if (errmsg) {
1438 PyErr_Format(PyExc_OverflowError,
1439 "value %ld is greater than '%s' maximum %ld",
1440 value, errmsg, max_value);
1441 }
1442 return 0;
1443 }
1444 return 1;
1445 }
1446
1447
1448 SWIGINTERN int
1449 SWIG_AsVal_long(PyObject* obj, long* val)
1450 {
1451 if (PyNumber_Check(obj)) {
1452 if (val) *val = PyInt_AsLong(obj);
1453 return 1;
1454 }
1455 else {
1456 SWIG_type_error("number", obj);
1457 }
1458 return 0;
1459 }
1460
1461
1462 #if INT_MAX != LONG_MAX
1463 SWIGINTERN int
1464 SWIG_AsVal_int(PyObject *obj, int *val)
1465 {
1466 const char* errmsg = val ? "int" : (char*)0;
1467 long v;
1468 if (SWIG_AsVal_long(obj, &v)) {
1469 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1470 if (val) *val = (int)(v);
1471 return 1;
1472 } else {
1473 return 0;
1474 }
1475 } else {
1476 PyErr_Clear();
1477 }
1478 if (val) {
1479 SWIG_type_error(errmsg, obj);
1480 }
1481 return 0;
1482 }
1483 #else
1484 SWIGINTERNSHORT int
1485 SWIG_AsVal_int(PyObject *obj, int *val)
1486 {
1487 return SWIG_AsVal_long(obj,(long*)val);
1488 }
1489 #endif
1490
1491
1492 SWIGINTERN int
1493 SWIG_AsVal_bool(PyObject *obj, bool *val)
1494 {
1495 if (obj == Py_True) {
1496 if (val) *val = true;
1497 return 1;
1498 }
1499 if (obj == Py_False) {
1500 if (val) *val = false;
1501 return 1;
1502 }
1503 int res = 0;
1504 if (SWIG_AsVal_int(obj, &res)) {
1505 if (val) *val = res ? true : false;
1506 return 1;
1507 } else {
1508 PyErr_Clear();
1509 }
1510 if (val) {
1511 SWIG_type_error("bool", obj);
1512 }
1513 return 0;
1514 }
1515
1516
1517 SWIGINTERNSHORT bool
1518 SWIG_As_bool(PyObject* obj)
1519 {
1520 bool v;
1521 if (!SWIG_AsVal_bool(obj, &v)) {
1522 /*
1523 this is needed to make valgrind/purify happier.
1524 */
1525 memset((void*)&v, 0, sizeof(bool));
1526 }
1527 return v;
1528 }
1529
1530
1531 SWIGINTERNSHORT int
1532 SWIG_Check_bool(PyObject* obj)
1533 {
1534 return SWIG_AsVal_bool(obj, (bool*)0);
1535 }
1536
1537
1538 SWIGINTERN int
1539 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1540 {
1541 long v = 0;
1542 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1543 SWIG_type_error("unsigned number", obj);
1544 }
1545 else if (val)
1546 *val = (unsigned long)v;
1547 return 1;
1548 }
1549
1550
1551 SWIGINTERNSHORT int
1552 SWIG_CheckUnsignedLongInRange(unsigned long value,
1553 unsigned long max_value,
1554 const char *errmsg)
1555 {
1556 if (value > max_value) {
1557 if (errmsg) {
1558 PyErr_Format(PyExc_OverflowError,
1559 "value %lu is greater than '%s' minimum %lu",
1560 value, errmsg, max_value);
1561 }
1562 return 0;
1563 }
1564 return 1;
1565 }
1566
1567
1568 SWIGINTERN int
1569 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1570 {
1571 const char* errmsg = val ? "unsigned char" : (char*)0;
1572 unsigned long v;
1573 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1574 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1575 if (val) *val = (unsigned char)(v);
1576 return 1;
1577 } else {
1578 return 0;
1579 }
1580 } else {
1581 PyErr_Clear();
1582 }
1583 if (val) {
1584 SWIG_type_error(errmsg, obj);
1585 }
1586 return 0;
1587 }
1588
1589
1590 SWIGINTERNSHORT unsigned char
1591 SWIG_As_unsigned_SS_char(PyObject* obj)
1592 {
1593 unsigned char v;
1594 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1595 /*
1596 this is needed to make valgrind/purify happier.
1597 */
1598 memset((void*)&v, 0, sizeof(unsigned char));
1599 }
1600 return v;
1601 }
1602
1603
1604 SWIGINTERNSHORT int
1605 SWIG_Check_unsigned_SS_char(PyObject* obj)
1606 {
1607 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1608 }
1609
1610
1611 SWIGINTERNSHORT unsigned long
1612 SWIG_As_unsigned_SS_long(PyObject* obj)
1613 {
1614 unsigned long v;
1615 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1616 /*
1617 this is needed to make valgrind/purify happier.
1618 */
1619 memset((void*)&v, 0, sizeof(unsigned long));
1620 }
1621 return v;
1622 }
1623
1624
1625 SWIGINTERNSHORT int
1626 SWIG_Check_unsigned_SS_long(PyObject* obj)
1627 {
1628 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1629 }
1630
1631
1632 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1633 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1634 /*@@*/
1635
1636
1637 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1638 #define SWIG_From_long PyInt_FromLong
1639 /*@@*/
1640
1641 static PyObject *wxColour_Get(wxColour *self){
1642 PyObject* rv = PyTuple_New(3);
1643 int red = -1;
1644 int green = -1;
1645 int blue = -1;
1646 if (self->Ok()) {
1647 red = self->Red();
1648 green = self->Green();
1649 blue = self->Blue();
1650 }
1651 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1652 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1653 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1654 return rv;
1655 }
1656 static unsigned long wxColour_GetRGB(wxColour *self){
1657 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1658 }
1659
1660 SWIGINTERNSHORT PyObject*
1661 SWIG_From_unsigned_SS_long(unsigned long value)
1662 {
1663 return (value > LONG_MAX) ?
1664 PyLong_FromUnsignedLong(value)
1665 : PyInt_FromLong((long)(value));
1666 }
1667
1668
1669 SWIGINTERNSHORT int
1670 SWIG_As_int(PyObject* obj)
1671 {
1672 int v;
1673 if (!SWIG_AsVal_int(obj, &v)) {
1674 /*
1675 this is needed to make valgrind/purify happier.
1676 */
1677 memset((void*)&v, 0, sizeof(int));
1678 }
1679 return v;
1680 }
1681
1682
1683 SWIGINTERNSHORT int
1684 SWIG_Check_int(PyObject* obj)
1685 {
1686 return SWIG_AsVal_int(obj, (int*)0);
1687 }
1688
1689
1690 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1691 #define SWIG_From_int PyInt_FromLong
1692 /*@@*/
1693
1694
1695 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1696 PyObject* o2;
1697 PyObject* o3;
1698
1699 if (!target) {
1700 target = o;
1701 } else if (target == Py_None) {
1702 Py_DECREF(Py_None);
1703 target = o;
1704 } else {
1705 if (!PyTuple_Check(target)) {
1706 o2 = target;
1707 target = PyTuple_New(1);
1708 PyTuple_SetItem(target, 0, o2);
1709 }
1710 o3 = PyTuple_New(1);
1711 PyTuple_SetItem(o3, 0, o);
1712
1713 o2 = target;
1714 target = PySequence_Concat(o2, o3);
1715 Py_DECREF(o2);
1716 Py_DECREF(o3);
1717 }
1718 return target;
1719 }
1720
1721
1722 static PyObject *wxPen_GetDashes(wxPen *self){
1723 wxDash* dashes;
1724 int count = self->GetDashes(&dashes);
1725 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1726 PyObject* retval = PyList_New(0);
1727 for (int x=0; x<count; x++) {
1728 PyObject* pyint = PyInt_FromLong(dashes[x]);
1729 PyList_Append(retval, pyint);
1730 Py_DECREF(pyint);
1731 }
1732 wxPyEndBlockThreads(blocked);
1733 return retval;
1734 }
1735 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1736 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1737 int size = PyList_Size(pyDashes);
1738 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1739
1740 // black magic warning! The array of wxDashes needs to exist as
1741 // long as the pen does because wxPen does not copy the array. So
1742 // stick a copy in a Python string object and attach it to _self,
1743 // and then call SetDashes with a pointer to that array. Then
1744 // when the Python pen object is destroyed the array will be
1745 // cleaned up too.
1746 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1747 PyObject_SetAttrString(_self, "_dashes", strDashes);
1748
1749 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1750 delete [] dashes;
1751 Py_DECREF(strDashes);
1752 wxPyEndBlockThreads(blocked);
1753 }
1754 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1755 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1756
1757 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1758 #define SWIG_From_short PyInt_FromLong
1759 /*@@*/
1760
1761
1762 SWIGINTERN int
1763 SWIG_AsVal_short(PyObject *obj, short *val)
1764 {
1765 const char* errmsg = val ? "short" : (char*)0;
1766 long v;
1767 if (SWIG_AsVal_long(obj, &v)) {
1768 if (SWIG_CheckLongInRange(v, SHRT_MIN, SHRT_MAX, errmsg)) {
1769 if (val) *val = (short)(v);
1770 return 1;
1771 } else {
1772 return 0;
1773 }
1774 } else {
1775 PyErr_Clear();
1776 }
1777 if (val) {
1778 SWIG_type_error(errmsg, obj);
1779 }
1780 return 0;
1781 }
1782
1783
1784 SWIGINTERNSHORT short
1785 SWIG_As_short(PyObject* obj)
1786 {
1787 short v;
1788 if (!SWIG_AsVal_short(obj, &v)) {
1789 /*
1790 this is needed to make valgrind/purify happier.
1791 */
1792 memset((void*)&v, 0, sizeof(short));
1793 }
1794 return v;
1795 }
1796
1797
1798 SWIGINTERNSHORT int
1799 SWIG_Check_short(PyObject* obj)
1800 {
1801 return SWIG_AsVal_short(obj, (short*)0);
1802 }
1803
1804
1805 #include <wx/image.h>
1806
1807 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1808 char** cArray = NULL;
1809 int count;
1810
1811 if (!PyList_Check(listOfStrings)) {
1812 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1813 return NULL;
1814 }
1815 count = PyList_Size(listOfStrings);
1816 cArray = new char*[count];
1817
1818 for(int x=0; x<count; x++) {
1819 // TODO: Need some validation and error checking here
1820 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1821 }
1822 return cArray;
1823 }
1824
1825
1826 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1827 char** cArray = NULL;
1828 wxBitmap* bmp;
1829
1830 cArray = ConvertListOfStrings(listOfStrings);
1831 if (! cArray)
1832 return NULL;
1833 bmp = new wxBitmap(cArray);
1834 delete [] cArray;
1835 return bmp;
1836 }
1837 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1838 char* buf;
1839 int length;
1840 PyString_AsStringAndSize(bits, &buf, &length);
1841 return new wxBitmap(buf, width, height, depth);
1842 }
1843 static wxSize wxBitmap_GetSize(wxBitmap *self){
1844 wxSize size(self->GetWidth(), self->GetHeight());
1845 return size;
1846 }
1847 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1848 wxMask *mask = new wxMask(*self, colour);
1849 self->SetMask(mask);
1850 }
1851 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1852 self->SetWidth(size.x);
1853 self->SetHeight(size.y);
1854 }
1855 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1856 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1857 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1858 if ( !colour.Ok() )
1859 return new wxMask(bitmap, *wxBLACK);
1860 else
1861 return new wxMask(bitmap, colour);
1862 }
1863
1864 #include <wx/iconbndl.h>
1865
1866 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1867 wxIcon* icon = new wxIcon();
1868 icon->CopyFromBitmap(bmp);
1869 return icon;
1870 }
1871 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1872 char** cArray = NULL;
1873 wxIcon* icon;
1874
1875 cArray = ConvertListOfStrings(listOfStrings);
1876 if (! cArray)
1877 return NULL;
1878 icon = new wxIcon(cArray);
1879 delete [] cArray;
1880 return icon;
1881 }
1882 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1883
1884
1885
1886 return new wxIconLocation(*filename);
1887
1888 }
1889 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1890
1891
1892
1893 // do nothing
1894
1895 }
1896 static int wxIconLocation_GetIndex(wxIconLocation *self){
1897
1898
1899
1900 return -1;
1901
1902 }
1903
1904 SWIGINTERNSHORT long
1905 SWIG_As_long(PyObject* obj)
1906 {
1907 long v;
1908 if (!SWIG_AsVal_long(obj, &v)) {
1909 /*
1910 this is needed to make valgrind/purify happier.
1911 */
1912 memset((void*)&v, 0, sizeof(long));
1913 }
1914 return v;
1915 }
1916
1917
1918 SWIGINTERNSHORT int
1919 SWIG_Check_long(PyObject* obj)
1920 {
1921 return SWIG_AsVal_long(obj, (long*)0);
1922 }
1923
1924 static wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1925 #ifdef __WXGTK__
1926 wxImage img(cursorName, type);
1927 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
1928 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
1929 return new wxCursor(img);
1930 #else
1931 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
1932 #endif
1933 }
1934
1935
1936 static void wxRegionIterator_Next(wxRegionIterator *self){
1937 (*self) ++;
1938 }
1939 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1940 return self->operator bool();
1941 }
1942
1943 #include <wx/fontutil.h>
1944 #include <wx/fontmap.h>
1945 #include <wx/fontenum.h>
1946
1947 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1948 return self->ToString();
1949 }
1950
1951 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
1952 static wxNativeEncodingInfo info;
1953 if ( wxGetNativeFontEncoding(encoding, &info) )
1954 return &info;
1955 else
1956 return NULL;
1957 }
1958
1959 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1960 wxFontEncoding alt_enc;
1961 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1962 return PyInt_FromLong(alt_enc);
1963 else {
1964 Py_INCREF(Py_None);
1965 return Py_None;
1966 }
1967 }
1968 static wxFont *new_wxFont(wxString const &info){
1969 wxNativeFontInfo nfi;
1970 nfi.FromString(info);
1971 return new wxFont(nfi);
1972 }
1973 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1974 return wxFont::New(pointSize, family, flags, face, encoding);
1975 }
1976 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1977 return wxFontBase::New(pixelSize, family,
1978 style, weight, underlined,
1979 face, encoding);
1980 }
1981 static wxFont *new_wxFont(wxSize const &pixelSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1982 return wxFontBase::New(pixelSize, family, flags, face, encoding);
1983 }
1984 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1985 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1986
1987 class wxPyFontEnumerator : public wxFontEnumerator {
1988 public:
1989 wxPyFontEnumerator() {}
1990 ~wxPyFontEnumerator() {}
1991
1992 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1993 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1994
1995 PYPRIVATE;
1996 };
1997
1998 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
1999 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
2000
2001
2002 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
2003 wxArrayString* arr = self->GetEncodings();
2004 if (arr)
2005 return wxArrayString2PyList_helper(*arr);
2006 else
2007 return PyList_New(0);
2008 }
2009 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
2010 wxArrayString* arr = self->GetFacenames();
2011 if (arr)
2012 return wxArrayString2PyList_helper(*arr);
2013 else
2014 return PyList_New(0);
2015 }
2016
2017 #include <locale.h>
2018
2019 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
2020 wxLocale* loc;
2021 if (language == -1)
2022 loc = new wxLocale();
2023 else
2024 loc = new wxLocale(language, flags);
2025 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2026 // for the floating point conversions and such to work right.
2027 #if PY_VERSION_HEX < 0x02040000
2028 setlocale(LC_NUMERIC, "C");
2029 #endif
2030 return loc;
2031 }
2032 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
2033 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
2034 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2035 // for the floating point conversions and such to work right.
2036 #if PY_VERSION_HEX < 0x02040000
2037 setlocale(LC_NUMERIC, "C");
2038 #endif
2039 return rc;
2040 }
2041 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
2042 bool rc = self->Init(language, flags);
2043 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2044 // for the floating point conversions and such to work right.
2045 #if PY_VERSION_HEX < 0x02040000
2046 setlocale(LC_NUMERIC, "C");
2047 #endif
2048 return rc;
2049 }
2050
2051 #include "wx/wxPython/pydrawxxx.h"
2052
2053 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2054 wxColour col;
2055 self->GetPixel(x, y, &col);
2056 return col;
2057 }
2058 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2059 wxColour col;
2060 self->GetPixel(pt, &col);
2061 return col;
2062 }
2063
2064 SWIGINTERN int
2065 SWIG_AsVal_double(PyObject *obj, double* val)
2066 {
2067 if (PyNumber_Check(obj)) {
2068 if (val) *val = PyFloat_AsDouble(obj);
2069 return 1;
2070 }
2071 else {
2072 SWIG_type_error("number", obj);
2073 }
2074 return 0;
2075 }
2076
2077
2078 SWIGINTERNSHORT double
2079 SWIG_As_double(PyObject* obj)
2080 {
2081 double v;
2082 if (!SWIG_AsVal_double(obj, &v)) {
2083 /*
2084 this is needed to make valgrind/purify happier.
2085 */
2086 memset((void*)&v, 0, sizeof(double));
2087 }
2088 return v;
2089 }
2090
2091
2092 SWIGINTERNSHORT int
2093 SWIG_Check_double(PyObject* obj)
2094 {
2095 return SWIG_AsVal_double(obj, (double*)0);
2096 }
2097
2098 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2099 wxRect rv;
2100 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2101 return rv;
2102 }
2103
2104 static wxRect wxDC_GetClippingRect(wxDC *self){
2105 wxRect rect;
2106 self->GetClippingBox(rect);
2107 return rect;
2108 }
2109 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2110 wxArrayInt widths;
2111 self->GetPartialTextExtents(text, widths);
2112 return widths;
2113 }
2114
2115 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2116 #define SWIG_From_double PyFloat_FromDouble
2117 /*@@*/
2118
2119
2120 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2121 self->SetLogicalOrigin(point.x, point.y);
2122 }
2123 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2124 self->SetDeviceOrigin(point.x, point.y);
2125 }
2126 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2127 self->CalcBoundingBox(point.x, point.y);
2128 }
2129 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2130 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2131 }
2132 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2133 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2134 }
2135 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2136 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2137 }
2138 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2139 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2140 }
2141 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2142 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2143 }
2144 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2145 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2146 }
2147
2148 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2149 *x1 = dc->MinX();
2150 *y1 = dc->MinY();
2151 *x2 = dc->MaxX();
2152 *y2 = dc->MaxY();
2153 }
2154
2155
2156 #include <wx/dcbuffer.h>
2157
2158
2159 #include <wx/dcps.h>
2160
2161
2162 #include <wx/metafile.h>
2163
2164
2165
2166 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2167 self->AddColour(name, wxColour(red, green, blue));
2168 }
2169
2170 #include <wx/effects.h>
2171
2172 #ifdef __cplusplus
2173 extern "C" {
2174 #endif
2175 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2176 PyObject *resultobj;
2177 wxGDIObject *result;
2178 char *kwnames[] = {
2179 NULL
2180 };
2181
2182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2183 {
2184 if (!wxPyCheckForApp()) SWIG_fail;
2185 PyThreadState* __tstate = wxPyBeginAllowThreads();
2186 result = (wxGDIObject *)new wxGDIObject();
2187
2188 wxPyEndAllowThreads(__tstate);
2189 if (PyErr_Occurred()) SWIG_fail;
2190 }
2191 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2192 return resultobj;
2193 fail:
2194 return NULL;
2195 }
2196
2197
2198 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2199 PyObject *resultobj;
2200 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2201 PyObject * obj0 = 0 ;
2202 char *kwnames[] = {
2203 (char *) "self", NULL
2204 };
2205
2206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2208 if (SWIG_arg_fail(1)) SWIG_fail;
2209 {
2210 PyThreadState* __tstate = wxPyBeginAllowThreads();
2211 delete arg1;
2212
2213 wxPyEndAllowThreads(__tstate);
2214 if (PyErr_Occurred()) SWIG_fail;
2215 }
2216 Py_INCREF(Py_None); resultobj = Py_None;
2217 return resultobj;
2218 fail:
2219 return NULL;
2220 }
2221
2222
2223 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2224 PyObject *resultobj;
2225 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2226 bool result;
2227 PyObject * obj0 = 0 ;
2228 char *kwnames[] = {
2229 (char *) "self", NULL
2230 };
2231
2232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2234 if (SWIG_arg_fail(1)) SWIG_fail;
2235 {
2236 PyThreadState* __tstate = wxPyBeginAllowThreads();
2237 result = (bool)(arg1)->GetVisible();
2238
2239 wxPyEndAllowThreads(__tstate);
2240 if (PyErr_Occurred()) SWIG_fail;
2241 }
2242 {
2243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2244 }
2245 return resultobj;
2246 fail:
2247 return NULL;
2248 }
2249
2250
2251 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2252 PyObject *resultobj;
2253 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2254 bool arg2 ;
2255 PyObject * obj0 = 0 ;
2256 PyObject * obj1 = 0 ;
2257 char *kwnames[] = {
2258 (char *) "self",(char *) "visible", NULL
2259 };
2260
2261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2263 if (SWIG_arg_fail(1)) SWIG_fail;
2264 {
2265 arg2 = (bool)(SWIG_As_bool(obj1));
2266 if (SWIG_arg_fail(2)) SWIG_fail;
2267 }
2268 {
2269 PyThreadState* __tstate = wxPyBeginAllowThreads();
2270 (arg1)->SetVisible(arg2);
2271
2272 wxPyEndAllowThreads(__tstate);
2273 if (PyErr_Occurred()) SWIG_fail;
2274 }
2275 Py_INCREF(Py_None); resultobj = Py_None;
2276 return resultobj;
2277 fail:
2278 return NULL;
2279 }
2280
2281
2282 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2283 PyObject *resultobj;
2284 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2285 bool result;
2286 PyObject * obj0 = 0 ;
2287 char *kwnames[] = {
2288 (char *) "self", NULL
2289 };
2290
2291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2293 if (SWIG_arg_fail(1)) SWIG_fail;
2294 {
2295 PyThreadState* __tstate = wxPyBeginAllowThreads();
2296 result = (bool)(arg1)->IsNull();
2297
2298 wxPyEndAllowThreads(__tstate);
2299 if (PyErr_Occurred()) SWIG_fail;
2300 }
2301 {
2302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2303 }
2304 return resultobj;
2305 fail:
2306 return NULL;
2307 }
2308
2309
2310 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2311 PyObject *obj;
2312 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2313 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2314 Py_INCREF(obj);
2315 return Py_BuildValue((char *)"");
2316 }
2317 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2318 PyObject *resultobj;
2319 byte arg1 = (byte) 0 ;
2320 byte arg2 = (byte) 0 ;
2321 byte arg3 = (byte) 0 ;
2322 wxColour *result;
2323 PyObject * obj0 = 0 ;
2324 PyObject * obj1 = 0 ;
2325 PyObject * obj2 = 0 ;
2326 char *kwnames[] = {
2327 (char *) "red",(char *) "green",(char *) "blue", NULL
2328 };
2329
2330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2331 if (obj0) {
2332 {
2333 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2334 if (SWIG_arg_fail(1)) SWIG_fail;
2335 }
2336 }
2337 if (obj1) {
2338 {
2339 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2340 if (SWIG_arg_fail(2)) SWIG_fail;
2341 }
2342 }
2343 if (obj2) {
2344 {
2345 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2346 if (SWIG_arg_fail(3)) SWIG_fail;
2347 }
2348 }
2349 {
2350 PyThreadState* __tstate = wxPyBeginAllowThreads();
2351 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2352
2353 wxPyEndAllowThreads(__tstate);
2354 if (PyErr_Occurred()) SWIG_fail;
2355 }
2356 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2357 return resultobj;
2358 fail:
2359 return NULL;
2360 }
2361
2362
2363 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2364 PyObject *resultobj;
2365 wxString *arg1 = 0 ;
2366 wxColour *result;
2367 bool temp1 = false ;
2368 PyObject * obj0 = 0 ;
2369 char *kwnames[] = {
2370 (char *) "colorName", NULL
2371 };
2372
2373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2374 {
2375 arg1 = wxString_in_helper(obj0);
2376 if (arg1 == NULL) SWIG_fail;
2377 temp1 = true;
2378 }
2379 {
2380 if (!wxPyCheckForApp()) SWIG_fail;
2381 PyThreadState* __tstate = wxPyBeginAllowThreads();
2382 result = (wxColour *)new wxColour((wxString const &)*arg1);
2383
2384 wxPyEndAllowThreads(__tstate);
2385 if (PyErr_Occurred()) SWIG_fail;
2386 }
2387 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2388 {
2389 if (temp1)
2390 delete arg1;
2391 }
2392 return resultobj;
2393 fail:
2394 {
2395 if (temp1)
2396 delete arg1;
2397 }
2398 return NULL;
2399 }
2400
2401
2402 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2403 PyObject *resultobj;
2404 unsigned long arg1 ;
2405 wxColour *result;
2406 PyObject * obj0 = 0 ;
2407 char *kwnames[] = {
2408 (char *) "colRGB", NULL
2409 };
2410
2411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2412 {
2413 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2414 if (SWIG_arg_fail(1)) SWIG_fail;
2415 }
2416 {
2417 PyThreadState* __tstate = wxPyBeginAllowThreads();
2418 result = (wxColour *)new wxColour(arg1);
2419
2420 wxPyEndAllowThreads(__tstate);
2421 if (PyErr_Occurred()) SWIG_fail;
2422 }
2423 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2424 return resultobj;
2425 fail:
2426 return NULL;
2427 }
2428
2429
2430 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2431 PyObject *resultobj;
2432 wxColour *arg1 = (wxColour *) 0 ;
2433 PyObject * obj0 = 0 ;
2434 char *kwnames[] = {
2435 (char *) "self", NULL
2436 };
2437
2438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2440 if (SWIG_arg_fail(1)) SWIG_fail;
2441 {
2442 PyThreadState* __tstate = wxPyBeginAllowThreads();
2443 delete arg1;
2444
2445 wxPyEndAllowThreads(__tstate);
2446 if (PyErr_Occurred()) SWIG_fail;
2447 }
2448 Py_INCREF(Py_None); resultobj = Py_None;
2449 return resultobj;
2450 fail:
2451 return NULL;
2452 }
2453
2454
2455 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2456 PyObject *resultobj;
2457 wxColour *arg1 = (wxColour *) 0 ;
2458 byte result;
2459 PyObject * obj0 = 0 ;
2460 char *kwnames[] = {
2461 (char *) "self", NULL
2462 };
2463
2464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2466 if (SWIG_arg_fail(1)) SWIG_fail;
2467 {
2468 PyThreadState* __tstate = wxPyBeginAllowThreads();
2469 result = (byte)(arg1)->Red();
2470
2471 wxPyEndAllowThreads(__tstate);
2472 if (PyErr_Occurred()) SWIG_fail;
2473 }
2474 {
2475 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2476 }
2477 return resultobj;
2478 fail:
2479 return NULL;
2480 }
2481
2482
2483 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2484 PyObject *resultobj;
2485 wxColour *arg1 = (wxColour *) 0 ;
2486 byte result;
2487 PyObject * obj0 = 0 ;
2488 char *kwnames[] = {
2489 (char *) "self", NULL
2490 };
2491
2492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2494 if (SWIG_arg_fail(1)) SWIG_fail;
2495 {
2496 PyThreadState* __tstate = wxPyBeginAllowThreads();
2497 result = (byte)(arg1)->Green();
2498
2499 wxPyEndAllowThreads(__tstate);
2500 if (PyErr_Occurred()) SWIG_fail;
2501 }
2502 {
2503 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2504 }
2505 return resultobj;
2506 fail:
2507 return NULL;
2508 }
2509
2510
2511 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2512 PyObject *resultobj;
2513 wxColour *arg1 = (wxColour *) 0 ;
2514 byte result;
2515 PyObject * obj0 = 0 ;
2516 char *kwnames[] = {
2517 (char *) "self", NULL
2518 };
2519
2520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2522 if (SWIG_arg_fail(1)) SWIG_fail;
2523 {
2524 PyThreadState* __tstate = wxPyBeginAllowThreads();
2525 result = (byte)(arg1)->Blue();
2526
2527 wxPyEndAllowThreads(__tstate);
2528 if (PyErr_Occurred()) SWIG_fail;
2529 }
2530 {
2531 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2532 }
2533 return resultobj;
2534 fail:
2535 return NULL;
2536 }
2537
2538
2539 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2540 PyObject *resultobj;
2541 wxColour *arg1 = (wxColour *) 0 ;
2542 bool result;
2543 PyObject * obj0 = 0 ;
2544 char *kwnames[] = {
2545 (char *) "self", NULL
2546 };
2547
2548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
2553 result = (bool)(arg1)->Ok();
2554
2555 wxPyEndAllowThreads(__tstate);
2556 if (PyErr_Occurred()) SWIG_fail;
2557 }
2558 {
2559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2560 }
2561 return resultobj;
2562 fail:
2563 return NULL;
2564 }
2565
2566
2567 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2568 PyObject *resultobj;
2569 wxColour *arg1 = (wxColour *) 0 ;
2570 byte arg2 ;
2571 byte arg3 ;
2572 byte arg4 ;
2573 PyObject * obj0 = 0 ;
2574 PyObject * obj1 = 0 ;
2575 PyObject * obj2 = 0 ;
2576 PyObject * obj3 = 0 ;
2577 char *kwnames[] = {
2578 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2579 };
2580
2581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2583 if (SWIG_arg_fail(1)) SWIG_fail;
2584 {
2585 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2586 if (SWIG_arg_fail(2)) SWIG_fail;
2587 }
2588 {
2589 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2590 if (SWIG_arg_fail(3)) SWIG_fail;
2591 }
2592 {
2593 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2594 if (SWIG_arg_fail(4)) SWIG_fail;
2595 }
2596 {
2597 PyThreadState* __tstate = wxPyBeginAllowThreads();
2598 (arg1)->Set(arg2,arg3,arg4);
2599
2600 wxPyEndAllowThreads(__tstate);
2601 if (PyErr_Occurred()) SWIG_fail;
2602 }
2603 Py_INCREF(Py_None); resultobj = Py_None;
2604 return resultobj;
2605 fail:
2606 return NULL;
2607 }
2608
2609
2610 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2611 PyObject *resultobj;
2612 wxColour *arg1 = (wxColour *) 0 ;
2613 unsigned long arg2 ;
2614 PyObject * obj0 = 0 ;
2615 PyObject * obj1 = 0 ;
2616 char *kwnames[] = {
2617 (char *) "self",(char *) "colRGB", NULL
2618 };
2619
2620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2622 if (SWIG_arg_fail(1)) SWIG_fail;
2623 {
2624 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2625 if (SWIG_arg_fail(2)) SWIG_fail;
2626 }
2627 {
2628 PyThreadState* __tstate = wxPyBeginAllowThreads();
2629 (arg1)->Set(arg2);
2630
2631 wxPyEndAllowThreads(__tstate);
2632 if (PyErr_Occurred()) SWIG_fail;
2633 }
2634 Py_INCREF(Py_None); resultobj = Py_None;
2635 return resultobj;
2636 fail:
2637 return NULL;
2638 }
2639
2640
2641 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2642 PyObject *resultobj;
2643 wxColour *arg1 = (wxColour *) 0 ;
2644 wxString *arg2 = 0 ;
2645 bool temp2 = false ;
2646 PyObject * obj0 = 0 ;
2647 PyObject * obj1 = 0 ;
2648 char *kwnames[] = {
2649 (char *) "self",(char *) "colourName", NULL
2650 };
2651
2652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2654 if (SWIG_arg_fail(1)) SWIG_fail;
2655 {
2656 arg2 = wxString_in_helper(obj1);
2657 if (arg2 == NULL) SWIG_fail;
2658 temp2 = true;
2659 }
2660 {
2661 PyThreadState* __tstate = wxPyBeginAllowThreads();
2662 (arg1)->InitFromName((wxString const &)*arg2);
2663
2664 wxPyEndAllowThreads(__tstate);
2665 if (PyErr_Occurred()) SWIG_fail;
2666 }
2667 Py_INCREF(Py_None); resultobj = Py_None;
2668 {
2669 if (temp2)
2670 delete arg2;
2671 }
2672 return resultobj;
2673 fail:
2674 {
2675 if (temp2)
2676 delete arg2;
2677 }
2678 return NULL;
2679 }
2680
2681
2682 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2683 PyObject *resultobj;
2684 wxColour *arg1 = (wxColour *) 0 ;
2685 long result;
2686 PyObject * obj0 = 0 ;
2687 char *kwnames[] = {
2688 (char *) "self", NULL
2689 };
2690
2691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2693 if (SWIG_arg_fail(1)) SWIG_fail;
2694 {
2695 PyThreadState* __tstate = wxPyBeginAllowThreads();
2696 result = (long)((wxColour const *)arg1)->GetPixel();
2697
2698 wxPyEndAllowThreads(__tstate);
2699 if (PyErr_Occurred()) SWIG_fail;
2700 }
2701 {
2702 resultobj = SWIG_From_long((long)(result));
2703 }
2704 return resultobj;
2705 fail:
2706 return NULL;
2707 }
2708
2709
2710 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2711 PyObject *resultobj;
2712 wxColour *arg1 = (wxColour *) 0 ;
2713 wxColour *arg2 = 0 ;
2714 bool result;
2715 wxColour temp2 ;
2716 PyObject * obj0 = 0 ;
2717 PyObject * obj1 = 0 ;
2718 char *kwnames[] = {
2719 (char *) "self",(char *) "colour", NULL
2720 };
2721
2722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2724 if (SWIG_arg_fail(1)) SWIG_fail;
2725 {
2726 arg2 = &temp2;
2727 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2728 }
2729 {
2730 PyThreadState* __tstate = wxPyBeginAllowThreads();
2731 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2732
2733 wxPyEndAllowThreads(__tstate);
2734 if (PyErr_Occurred()) SWIG_fail;
2735 }
2736 {
2737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2738 }
2739 return resultobj;
2740 fail:
2741 return NULL;
2742 }
2743
2744
2745 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2746 PyObject *resultobj;
2747 wxColour *arg1 = (wxColour *) 0 ;
2748 wxColour *arg2 = 0 ;
2749 bool result;
2750 wxColour temp2 ;
2751 PyObject * obj0 = 0 ;
2752 PyObject * obj1 = 0 ;
2753 char *kwnames[] = {
2754 (char *) "self",(char *) "colour", NULL
2755 };
2756
2757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2759 if (SWIG_arg_fail(1)) SWIG_fail;
2760 {
2761 arg2 = &temp2;
2762 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2763 }
2764 {
2765 PyThreadState* __tstate = wxPyBeginAllowThreads();
2766 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2767
2768 wxPyEndAllowThreads(__tstate);
2769 if (PyErr_Occurred()) SWIG_fail;
2770 }
2771 {
2772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2773 }
2774 return resultobj;
2775 fail:
2776 return NULL;
2777 }
2778
2779
2780 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2781 PyObject *resultobj;
2782 wxColour *arg1 = (wxColour *) 0 ;
2783 PyObject *result;
2784 PyObject * obj0 = 0 ;
2785 char *kwnames[] = {
2786 (char *) "self", NULL
2787 };
2788
2789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2791 if (SWIG_arg_fail(1)) SWIG_fail;
2792 {
2793 PyThreadState* __tstate = wxPyBeginAllowThreads();
2794 result = (PyObject *)wxColour_Get(arg1);
2795
2796 wxPyEndAllowThreads(__tstate);
2797 if (PyErr_Occurred()) SWIG_fail;
2798 }
2799 resultobj = result;
2800 return resultobj;
2801 fail:
2802 return NULL;
2803 }
2804
2805
2806 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2807 PyObject *resultobj;
2808 wxColour *arg1 = (wxColour *) 0 ;
2809 unsigned long result;
2810 PyObject * obj0 = 0 ;
2811 char *kwnames[] = {
2812 (char *) "self", NULL
2813 };
2814
2815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2817 if (SWIG_arg_fail(1)) SWIG_fail;
2818 {
2819 PyThreadState* __tstate = wxPyBeginAllowThreads();
2820 result = (unsigned long)wxColour_GetRGB(arg1);
2821
2822 wxPyEndAllowThreads(__tstate);
2823 if (PyErr_Occurred()) SWIG_fail;
2824 }
2825 {
2826 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2827 }
2828 return resultobj;
2829 fail:
2830 return NULL;
2831 }
2832
2833
2834 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2835 PyObject *obj;
2836 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2837 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2838 Py_INCREF(obj);
2839 return Py_BuildValue((char *)"");
2840 }
2841 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2842 PyObject *resultobj;
2843 int arg1 ;
2844 unsigned char *arg2 = (unsigned char *) 0 ;
2845 unsigned char *arg3 = (unsigned char *) 0 ;
2846 unsigned char *arg4 = (unsigned char *) 0 ;
2847 wxPalette *result;
2848 PyObject * obj0 = 0 ;
2849 PyObject * obj1 = 0 ;
2850 PyObject * obj2 = 0 ;
2851 PyObject * obj3 = 0 ;
2852 char *kwnames[] = {
2853 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2854 };
2855
2856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2857 {
2858 arg1 = (int)(SWIG_As_int(obj0));
2859 if (SWIG_arg_fail(1)) SWIG_fail;
2860 }
2861 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2862 if (SWIG_arg_fail(2)) SWIG_fail;
2863 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2864 if (SWIG_arg_fail(3)) SWIG_fail;
2865 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2866 if (SWIG_arg_fail(4)) SWIG_fail;
2867 {
2868 if (!wxPyCheckForApp()) SWIG_fail;
2869 PyThreadState* __tstate = wxPyBeginAllowThreads();
2870 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2871
2872 wxPyEndAllowThreads(__tstate);
2873 if (PyErr_Occurred()) SWIG_fail;
2874 }
2875 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2876 return resultobj;
2877 fail:
2878 return NULL;
2879 }
2880
2881
2882 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2883 PyObject *resultobj;
2884 wxPalette *arg1 = (wxPalette *) 0 ;
2885 PyObject * obj0 = 0 ;
2886 char *kwnames[] = {
2887 (char *) "self", NULL
2888 };
2889
2890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2892 if (SWIG_arg_fail(1)) SWIG_fail;
2893 {
2894 PyThreadState* __tstate = wxPyBeginAllowThreads();
2895 delete arg1;
2896
2897 wxPyEndAllowThreads(__tstate);
2898 if (PyErr_Occurred()) SWIG_fail;
2899 }
2900 Py_INCREF(Py_None); resultobj = Py_None;
2901 return resultobj;
2902 fail:
2903 return NULL;
2904 }
2905
2906
2907 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2908 PyObject *resultobj;
2909 wxPalette *arg1 = (wxPalette *) 0 ;
2910 byte arg2 ;
2911 byte arg3 ;
2912 byte arg4 ;
2913 int result;
2914 PyObject * obj0 = 0 ;
2915 PyObject * obj1 = 0 ;
2916 PyObject * obj2 = 0 ;
2917 PyObject * obj3 = 0 ;
2918 char *kwnames[] = {
2919 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2920 };
2921
2922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2924 if (SWIG_arg_fail(1)) SWIG_fail;
2925 {
2926 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2927 if (SWIG_arg_fail(2)) SWIG_fail;
2928 }
2929 {
2930 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2931 if (SWIG_arg_fail(3)) SWIG_fail;
2932 }
2933 {
2934 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2935 if (SWIG_arg_fail(4)) SWIG_fail;
2936 }
2937 {
2938 PyThreadState* __tstate = wxPyBeginAllowThreads();
2939 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2940
2941 wxPyEndAllowThreads(__tstate);
2942 if (PyErr_Occurred()) SWIG_fail;
2943 }
2944 {
2945 resultobj = SWIG_From_int((int)(result));
2946 }
2947 return resultobj;
2948 fail:
2949 return NULL;
2950 }
2951
2952
2953 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2954 PyObject *resultobj;
2955 wxPalette *arg1 = (wxPalette *) 0 ;
2956 int arg2 ;
2957 byte *arg3 = (byte *) 0 ;
2958 byte *arg4 = (byte *) 0 ;
2959 byte *arg5 = (byte *) 0 ;
2960 bool result;
2961 byte temp3 ;
2962 int res3 = 0 ;
2963 byte temp4 ;
2964 int res4 = 0 ;
2965 byte temp5 ;
2966 int res5 = 0 ;
2967 PyObject * obj0 = 0 ;
2968 PyObject * obj1 = 0 ;
2969 char *kwnames[] = {
2970 (char *) "self",(char *) "pixel", NULL
2971 };
2972
2973 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2974 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2975 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2978 if (SWIG_arg_fail(1)) SWIG_fail;
2979 {
2980 arg2 = (int)(SWIG_As_int(obj1));
2981 if (SWIG_arg_fail(2)) SWIG_fail;
2982 }
2983 {
2984 PyThreadState* __tstate = wxPyBeginAllowThreads();
2985 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2986
2987 wxPyEndAllowThreads(__tstate);
2988 if (PyErr_Occurred()) SWIG_fail;
2989 }
2990 {
2991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2992 }
2993 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2994 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2995 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2996 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2997 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2998 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2999 return resultobj;
3000 fail:
3001 return NULL;
3002 }
3003
3004
3005 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
3006 PyObject *resultobj;
3007 wxPalette *arg1 = (wxPalette *) 0 ;
3008 int result;
3009 PyObject * obj0 = 0 ;
3010 char *kwnames[] = {
3011 (char *) "self", NULL
3012 };
3013
3014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
3015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3016 if (SWIG_arg_fail(1)) SWIG_fail;
3017 {
3018 PyThreadState* __tstate = wxPyBeginAllowThreads();
3019 result = (int)((wxPalette const *)arg1)->GetColoursCount();
3020
3021 wxPyEndAllowThreads(__tstate);
3022 if (PyErr_Occurred()) SWIG_fail;
3023 }
3024 {
3025 resultobj = SWIG_From_int((int)(result));
3026 }
3027 return resultobj;
3028 fail:
3029 return NULL;
3030 }
3031
3032
3033 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3034 PyObject *resultobj;
3035 wxPalette *arg1 = (wxPalette *) 0 ;
3036 bool result;
3037 PyObject * obj0 = 0 ;
3038 char *kwnames[] = {
3039 (char *) "self", NULL
3040 };
3041
3042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
3043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3044 if (SWIG_arg_fail(1)) SWIG_fail;
3045 {
3046 PyThreadState* __tstate = wxPyBeginAllowThreads();
3047 result = (bool)(arg1)->Ok();
3048
3049 wxPyEndAllowThreads(__tstate);
3050 if (PyErr_Occurred()) SWIG_fail;
3051 }
3052 {
3053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3054 }
3055 return resultobj;
3056 fail:
3057 return NULL;
3058 }
3059
3060
3061 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3062 PyObject *obj;
3063 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3064 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3065 Py_INCREF(obj);
3066 return Py_BuildValue((char *)"");
3067 }
3068 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3069 PyObject *resultobj;
3070 wxColour *arg1 = 0 ;
3071 int arg2 = (int) 1 ;
3072 int arg3 = (int) wxSOLID ;
3073 wxPen *result;
3074 wxColour temp1 ;
3075 PyObject * obj0 = 0 ;
3076 PyObject * obj1 = 0 ;
3077 PyObject * obj2 = 0 ;
3078 char *kwnames[] = {
3079 (char *) "colour",(char *) "width",(char *) "style", NULL
3080 };
3081
3082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3083 {
3084 arg1 = &temp1;
3085 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3086 }
3087 if (obj1) {
3088 {
3089 arg2 = (int)(SWIG_As_int(obj1));
3090 if (SWIG_arg_fail(2)) SWIG_fail;
3091 }
3092 }
3093 if (obj2) {
3094 {
3095 arg3 = (int)(SWIG_As_int(obj2));
3096 if (SWIG_arg_fail(3)) SWIG_fail;
3097 }
3098 }
3099 {
3100 if (!wxPyCheckForApp()) SWIG_fail;
3101 PyThreadState* __tstate = wxPyBeginAllowThreads();
3102 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3103
3104 wxPyEndAllowThreads(__tstate);
3105 if (PyErr_Occurred()) SWIG_fail;
3106 }
3107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3108 return resultobj;
3109 fail:
3110 return NULL;
3111 }
3112
3113
3114 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3115 PyObject *resultobj;
3116 wxPen *arg1 = (wxPen *) 0 ;
3117 PyObject * obj0 = 0 ;
3118 char *kwnames[] = {
3119 (char *) "self", NULL
3120 };
3121
3122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3124 if (SWIG_arg_fail(1)) SWIG_fail;
3125 {
3126 PyThreadState* __tstate = wxPyBeginAllowThreads();
3127 delete arg1;
3128
3129 wxPyEndAllowThreads(__tstate);
3130 if (PyErr_Occurred()) SWIG_fail;
3131 }
3132 Py_INCREF(Py_None); resultobj = Py_None;
3133 return resultobj;
3134 fail:
3135 return NULL;
3136 }
3137
3138
3139 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3140 PyObject *resultobj;
3141 wxPen *arg1 = (wxPen *) 0 ;
3142 int result;
3143 PyObject * obj0 = 0 ;
3144 char *kwnames[] = {
3145 (char *) "self", NULL
3146 };
3147
3148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3150 if (SWIG_arg_fail(1)) SWIG_fail;
3151 {
3152 PyThreadState* __tstate = wxPyBeginAllowThreads();
3153 result = (int)(arg1)->GetCap();
3154
3155 wxPyEndAllowThreads(__tstate);
3156 if (PyErr_Occurred()) SWIG_fail;
3157 }
3158 {
3159 resultobj = SWIG_From_int((int)(result));
3160 }
3161 return resultobj;
3162 fail:
3163 return NULL;
3164 }
3165
3166
3167 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3168 PyObject *resultobj;
3169 wxPen *arg1 = (wxPen *) 0 ;
3170 wxColour result;
3171 PyObject * obj0 = 0 ;
3172 char *kwnames[] = {
3173 (char *) "self", NULL
3174 };
3175
3176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3178 if (SWIG_arg_fail(1)) SWIG_fail;
3179 {
3180 PyThreadState* __tstate = wxPyBeginAllowThreads();
3181 result = (arg1)->GetColour();
3182
3183 wxPyEndAllowThreads(__tstate);
3184 if (PyErr_Occurred()) SWIG_fail;
3185 }
3186 {
3187 wxColour * resultptr;
3188 resultptr = new wxColour((wxColour &)(result));
3189 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3190 }
3191 return resultobj;
3192 fail:
3193 return NULL;
3194 }
3195
3196
3197 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3198 PyObject *resultobj;
3199 wxPen *arg1 = (wxPen *) 0 ;
3200 int result;
3201 PyObject * obj0 = 0 ;
3202 char *kwnames[] = {
3203 (char *) "self", NULL
3204 };
3205
3206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3208 if (SWIG_arg_fail(1)) SWIG_fail;
3209 {
3210 PyThreadState* __tstate = wxPyBeginAllowThreads();
3211 result = (int)(arg1)->GetJoin();
3212
3213 wxPyEndAllowThreads(__tstate);
3214 if (PyErr_Occurred()) SWIG_fail;
3215 }
3216 {
3217 resultobj = SWIG_From_int((int)(result));
3218 }
3219 return resultobj;
3220 fail:
3221 return NULL;
3222 }
3223
3224
3225 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3226 PyObject *resultobj;
3227 wxPen *arg1 = (wxPen *) 0 ;
3228 int result;
3229 PyObject * obj0 = 0 ;
3230 char *kwnames[] = {
3231 (char *) "self", NULL
3232 };
3233
3234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3236 if (SWIG_arg_fail(1)) SWIG_fail;
3237 {
3238 PyThreadState* __tstate = wxPyBeginAllowThreads();
3239 result = (int)(arg1)->GetStyle();
3240
3241 wxPyEndAllowThreads(__tstate);
3242 if (PyErr_Occurred()) SWIG_fail;
3243 }
3244 {
3245 resultobj = SWIG_From_int((int)(result));
3246 }
3247 return resultobj;
3248 fail:
3249 return NULL;
3250 }
3251
3252
3253 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3254 PyObject *resultobj;
3255 wxPen *arg1 = (wxPen *) 0 ;
3256 int result;
3257 PyObject * obj0 = 0 ;
3258 char *kwnames[] = {
3259 (char *) "self", NULL
3260 };
3261
3262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3264 if (SWIG_arg_fail(1)) SWIG_fail;
3265 {
3266 PyThreadState* __tstate = wxPyBeginAllowThreads();
3267 result = (int)(arg1)->GetWidth();
3268
3269 wxPyEndAllowThreads(__tstate);
3270 if (PyErr_Occurred()) SWIG_fail;
3271 }
3272 {
3273 resultobj = SWIG_From_int((int)(result));
3274 }
3275 return resultobj;
3276 fail:
3277 return NULL;
3278 }
3279
3280
3281 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3282 PyObject *resultobj;
3283 wxPen *arg1 = (wxPen *) 0 ;
3284 bool result;
3285 PyObject * obj0 = 0 ;
3286 char *kwnames[] = {
3287 (char *) "self", NULL
3288 };
3289
3290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3292 if (SWIG_arg_fail(1)) SWIG_fail;
3293 {
3294 PyThreadState* __tstate = wxPyBeginAllowThreads();
3295 result = (bool)(arg1)->Ok();
3296
3297 wxPyEndAllowThreads(__tstate);
3298 if (PyErr_Occurred()) SWIG_fail;
3299 }
3300 {
3301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3302 }
3303 return resultobj;
3304 fail:
3305 return NULL;
3306 }
3307
3308
3309 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3310 PyObject *resultobj;
3311 wxPen *arg1 = (wxPen *) 0 ;
3312 int arg2 ;
3313 PyObject * obj0 = 0 ;
3314 PyObject * obj1 = 0 ;
3315 char *kwnames[] = {
3316 (char *) "self",(char *) "cap_style", NULL
3317 };
3318
3319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3321 if (SWIG_arg_fail(1)) SWIG_fail;
3322 {
3323 arg2 = (int)(SWIG_As_int(obj1));
3324 if (SWIG_arg_fail(2)) SWIG_fail;
3325 }
3326 {
3327 PyThreadState* __tstate = wxPyBeginAllowThreads();
3328 (arg1)->SetCap(arg2);
3329
3330 wxPyEndAllowThreads(__tstate);
3331 if (PyErr_Occurred()) SWIG_fail;
3332 }
3333 Py_INCREF(Py_None); resultobj = Py_None;
3334 return resultobj;
3335 fail:
3336 return NULL;
3337 }
3338
3339
3340 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3341 PyObject *resultobj;
3342 wxPen *arg1 = (wxPen *) 0 ;
3343 wxColour *arg2 = 0 ;
3344 wxColour temp2 ;
3345 PyObject * obj0 = 0 ;
3346 PyObject * obj1 = 0 ;
3347 char *kwnames[] = {
3348 (char *) "self",(char *) "colour", NULL
3349 };
3350
3351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3353 if (SWIG_arg_fail(1)) SWIG_fail;
3354 {
3355 arg2 = &temp2;
3356 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3357 }
3358 {
3359 PyThreadState* __tstate = wxPyBeginAllowThreads();
3360 (arg1)->SetColour(*arg2);
3361
3362 wxPyEndAllowThreads(__tstate);
3363 if (PyErr_Occurred()) SWIG_fail;
3364 }
3365 Py_INCREF(Py_None); resultobj = Py_None;
3366 return resultobj;
3367 fail:
3368 return NULL;
3369 }
3370
3371
3372 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3373 PyObject *resultobj;
3374 wxPen *arg1 = (wxPen *) 0 ;
3375 int arg2 ;
3376 PyObject * obj0 = 0 ;
3377 PyObject * obj1 = 0 ;
3378 char *kwnames[] = {
3379 (char *) "self",(char *) "join_style", NULL
3380 };
3381
3382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3384 if (SWIG_arg_fail(1)) SWIG_fail;
3385 {
3386 arg2 = (int)(SWIG_As_int(obj1));
3387 if (SWIG_arg_fail(2)) SWIG_fail;
3388 }
3389 {
3390 PyThreadState* __tstate = wxPyBeginAllowThreads();
3391 (arg1)->SetJoin(arg2);
3392
3393 wxPyEndAllowThreads(__tstate);
3394 if (PyErr_Occurred()) SWIG_fail;
3395 }
3396 Py_INCREF(Py_None); resultobj = Py_None;
3397 return resultobj;
3398 fail:
3399 return NULL;
3400 }
3401
3402
3403 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3404 PyObject *resultobj;
3405 wxPen *arg1 = (wxPen *) 0 ;
3406 int arg2 ;
3407 PyObject * obj0 = 0 ;
3408 PyObject * obj1 = 0 ;
3409 char *kwnames[] = {
3410 (char *) "self",(char *) "style", NULL
3411 };
3412
3413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3415 if (SWIG_arg_fail(1)) SWIG_fail;
3416 {
3417 arg2 = (int)(SWIG_As_int(obj1));
3418 if (SWIG_arg_fail(2)) SWIG_fail;
3419 }
3420 {
3421 PyThreadState* __tstate = wxPyBeginAllowThreads();
3422 (arg1)->SetStyle(arg2);
3423
3424 wxPyEndAllowThreads(__tstate);
3425 if (PyErr_Occurred()) SWIG_fail;
3426 }
3427 Py_INCREF(Py_None); resultobj = Py_None;
3428 return resultobj;
3429 fail:
3430 return NULL;
3431 }
3432
3433
3434 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3435 PyObject *resultobj;
3436 wxPen *arg1 = (wxPen *) 0 ;
3437 int arg2 ;
3438 PyObject * obj0 = 0 ;
3439 PyObject * obj1 = 0 ;
3440 char *kwnames[] = {
3441 (char *) "self",(char *) "width", NULL
3442 };
3443
3444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3446 if (SWIG_arg_fail(1)) SWIG_fail;
3447 {
3448 arg2 = (int)(SWIG_As_int(obj1));
3449 if (SWIG_arg_fail(2)) SWIG_fail;
3450 }
3451 {
3452 PyThreadState* __tstate = wxPyBeginAllowThreads();
3453 (arg1)->SetWidth(arg2);
3454
3455 wxPyEndAllowThreads(__tstate);
3456 if (PyErr_Occurred()) SWIG_fail;
3457 }
3458 Py_INCREF(Py_None); resultobj = Py_None;
3459 return resultobj;
3460 fail:
3461 return NULL;
3462 }
3463
3464
3465 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3466 PyObject *resultobj;
3467 wxPen *arg1 = (wxPen *) 0 ;
3468 int arg2 ;
3469 wxDash *arg3 = (wxDash *) 0 ;
3470 PyObject * obj0 = 0 ;
3471 PyObject * obj1 = 0 ;
3472 char *kwnames[] = {
3473 (char *) "self",(char *) "dashes", NULL
3474 };
3475
3476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3478 if (SWIG_arg_fail(1)) SWIG_fail;
3479 {
3480 arg2 = PyList_Size(obj1);
3481 arg3 = (wxDash*)byte_LIST_helper(obj1);
3482 if (arg3 == NULL) SWIG_fail;
3483 }
3484 {
3485 PyThreadState* __tstate = wxPyBeginAllowThreads();
3486 (arg1)->SetDashes(arg2,arg3);
3487
3488 wxPyEndAllowThreads(__tstate);
3489 if (PyErr_Occurred()) SWIG_fail;
3490 }
3491 Py_INCREF(Py_None); resultobj = Py_None;
3492 {
3493 if (arg3) delete [] arg3;
3494 }
3495 return resultobj;
3496 fail:
3497 {
3498 if (arg3) delete [] arg3;
3499 }
3500 return NULL;
3501 }
3502
3503
3504 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3505 PyObject *resultobj;
3506 wxPen *arg1 = (wxPen *) 0 ;
3507 PyObject *result;
3508 PyObject * obj0 = 0 ;
3509 char *kwnames[] = {
3510 (char *) "self", NULL
3511 };
3512
3513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3515 if (SWIG_arg_fail(1)) SWIG_fail;
3516 {
3517 PyThreadState* __tstate = wxPyBeginAllowThreads();
3518 result = (PyObject *)wxPen_GetDashes(arg1);
3519
3520 wxPyEndAllowThreads(__tstate);
3521 if (PyErr_Occurred()) SWIG_fail;
3522 }
3523 resultobj = result;
3524 return resultobj;
3525 fail:
3526 return NULL;
3527 }
3528
3529
3530 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3531 PyObject *resultobj;
3532 wxPen *arg1 = (wxPen *) 0 ;
3533 PyObject *arg2 = (PyObject *) 0 ;
3534 PyObject *arg3 = (PyObject *) 0 ;
3535 PyObject * obj0 = 0 ;
3536 PyObject * obj1 = 0 ;
3537 PyObject * obj2 = 0 ;
3538 char *kwnames[] = {
3539 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3540 };
3541
3542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3544 if (SWIG_arg_fail(1)) SWIG_fail;
3545 arg2 = obj1;
3546 arg3 = obj2;
3547 {
3548 PyThreadState* __tstate = wxPyBeginAllowThreads();
3549 wxPen__SetDashes(arg1,arg2,arg3);
3550
3551 wxPyEndAllowThreads(__tstate);
3552 if (PyErr_Occurred()) SWIG_fail;
3553 }
3554 Py_INCREF(Py_None); resultobj = Py_None;
3555 return resultobj;
3556 fail:
3557 return NULL;
3558 }
3559
3560
3561 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3562 PyObject *resultobj;
3563 wxPen *arg1 = (wxPen *) 0 ;
3564 wxPen *arg2 = (wxPen *) 0 ;
3565 bool result;
3566 PyObject * obj0 = 0 ;
3567 PyObject * obj1 = 0 ;
3568 char *kwnames[] = {
3569 (char *) "self",(char *) "other", NULL
3570 };
3571
3572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3574 if (SWIG_arg_fail(1)) SWIG_fail;
3575 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3576 if (SWIG_arg_fail(2)) SWIG_fail;
3577 {
3578 PyThreadState* __tstate = wxPyBeginAllowThreads();
3579 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3580
3581 wxPyEndAllowThreads(__tstate);
3582 if (PyErr_Occurred()) SWIG_fail;
3583 }
3584 {
3585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3586 }
3587 return resultobj;
3588 fail:
3589 return NULL;
3590 }
3591
3592
3593 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3594 PyObject *resultobj;
3595 wxPen *arg1 = (wxPen *) 0 ;
3596 wxPen *arg2 = (wxPen *) 0 ;
3597 bool result;
3598 PyObject * obj0 = 0 ;
3599 PyObject * obj1 = 0 ;
3600 char *kwnames[] = {
3601 (char *) "self",(char *) "other", NULL
3602 };
3603
3604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3606 if (SWIG_arg_fail(1)) SWIG_fail;
3607 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3608 if (SWIG_arg_fail(2)) SWIG_fail;
3609 {
3610 PyThreadState* __tstate = wxPyBeginAllowThreads();
3611 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3612
3613 wxPyEndAllowThreads(__tstate);
3614 if (PyErr_Occurred()) SWIG_fail;
3615 }
3616 {
3617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3618 }
3619 return resultobj;
3620 fail:
3621 return NULL;
3622 }
3623
3624
3625 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3626 PyObject *obj;
3627 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3628 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3629 Py_INCREF(obj);
3630 return Py_BuildValue((char *)"");
3631 }
3632 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3633 PyObject *resultobj;
3634 wxColour *arg1 = 0 ;
3635 int arg2 = (int) wxSOLID ;
3636 wxBrush *result;
3637 wxColour temp1 ;
3638 PyObject * obj0 = 0 ;
3639 PyObject * obj1 = 0 ;
3640 char *kwnames[] = {
3641 (char *) "colour",(char *) "style", NULL
3642 };
3643
3644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3645 {
3646 arg1 = &temp1;
3647 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3648 }
3649 if (obj1) {
3650 {
3651 arg2 = (int)(SWIG_As_int(obj1));
3652 if (SWIG_arg_fail(2)) SWIG_fail;
3653 }
3654 }
3655 {
3656 if (!wxPyCheckForApp()) SWIG_fail;
3657 PyThreadState* __tstate = wxPyBeginAllowThreads();
3658 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3659
3660 wxPyEndAllowThreads(__tstate);
3661 if (PyErr_Occurred()) SWIG_fail;
3662 }
3663 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3664 return resultobj;
3665 fail:
3666 return NULL;
3667 }
3668
3669
3670 static PyObject *_wrap_new_BrushFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3671 PyObject *resultobj;
3672 wxBitmap *arg1 = 0 ;
3673 wxBrush *result;
3674 PyObject * obj0 = 0 ;
3675 char *kwnames[] = {
3676 (char *) "stippleBitmap", NULL
3677 };
3678
3679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BrushFromBitmap",kwnames,&obj0)) goto fail;
3680 {
3681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3682 if (SWIG_arg_fail(1)) SWIG_fail;
3683 if (arg1 == NULL) {
3684 SWIG_null_ref("wxBitmap");
3685 }
3686 if (SWIG_arg_fail(1)) SWIG_fail;
3687 }
3688 {
3689 if (!wxPyCheckForApp()) SWIG_fail;
3690 PyThreadState* __tstate = wxPyBeginAllowThreads();
3691 result = (wxBrush *)new wxBrush((wxBitmap const &)*arg1);
3692
3693 wxPyEndAllowThreads(__tstate);
3694 if (PyErr_Occurred()) SWIG_fail;
3695 }
3696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3697 return resultobj;
3698 fail:
3699 return NULL;
3700 }
3701
3702
3703 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3704 PyObject *resultobj;
3705 wxBrush *arg1 = (wxBrush *) 0 ;
3706 PyObject * obj0 = 0 ;
3707 char *kwnames[] = {
3708 (char *) "self", NULL
3709 };
3710
3711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3713 if (SWIG_arg_fail(1)) SWIG_fail;
3714 {
3715 PyThreadState* __tstate = wxPyBeginAllowThreads();
3716 delete arg1;
3717
3718 wxPyEndAllowThreads(__tstate);
3719 if (PyErr_Occurred()) SWIG_fail;
3720 }
3721 Py_INCREF(Py_None); resultobj = Py_None;
3722 return resultobj;
3723 fail:
3724 return NULL;
3725 }
3726
3727
3728 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3729 PyObject *resultobj;
3730 wxBrush *arg1 = (wxBrush *) 0 ;
3731 wxColour *arg2 = 0 ;
3732 wxColour temp2 ;
3733 PyObject * obj0 = 0 ;
3734 PyObject * obj1 = 0 ;
3735 char *kwnames[] = {
3736 (char *) "self",(char *) "col", NULL
3737 };
3738
3739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3741 if (SWIG_arg_fail(1)) SWIG_fail;
3742 {
3743 arg2 = &temp2;
3744 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3745 }
3746 {
3747 PyThreadState* __tstate = wxPyBeginAllowThreads();
3748 (arg1)->SetColour((wxColour const &)*arg2);
3749
3750 wxPyEndAllowThreads(__tstate);
3751 if (PyErr_Occurred()) SWIG_fail;
3752 }
3753 Py_INCREF(Py_None); resultobj = Py_None;
3754 return resultobj;
3755 fail:
3756 return NULL;
3757 }
3758
3759
3760 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3761 PyObject *resultobj;
3762 wxBrush *arg1 = (wxBrush *) 0 ;
3763 int arg2 ;
3764 PyObject * obj0 = 0 ;
3765 PyObject * obj1 = 0 ;
3766 char *kwnames[] = {
3767 (char *) "self",(char *) "style", NULL
3768 };
3769
3770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3772 if (SWIG_arg_fail(1)) SWIG_fail;
3773 {
3774 arg2 = (int)(SWIG_As_int(obj1));
3775 if (SWIG_arg_fail(2)) SWIG_fail;
3776 }
3777 {
3778 PyThreadState* __tstate = wxPyBeginAllowThreads();
3779 (arg1)->SetStyle(arg2);
3780
3781 wxPyEndAllowThreads(__tstate);
3782 if (PyErr_Occurred()) SWIG_fail;
3783 }
3784 Py_INCREF(Py_None); resultobj = Py_None;
3785 return resultobj;
3786 fail:
3787 return NULL;
3788 }
3789
3790
3791 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3792 PyObject *resultobj;
3793 wxBrush *arg1 = (wxBrush *) 0 ;
3794 wxBitmap *arg2 = 0 ;
3795 PyObject * obj0 = 0 ;
3796 PyObject * obj1 = 0 ;
3797 char *kwnames[] = {
3798 (char *) "self",(char *) "stipple", NULL
3799 };
3800
3801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3803 if (SWIG_arg_fail(1)) SWIG_fail;
3804 {
3805 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3806 if (SWIG_arg_fail(2)) SWIG_fail;
3807 if (arg2 == NULL) {
3808 SWIG_null_ref("wxBitmap");
3809 }
3810 if (SWIG_arg_fail(2)) SWIG_fail;
3811 }
3812 {
3813 PyThreadState* __tstate = wxPyBeginAllowThreads();
3814 (arg1)->SetStipple((wxBitmap const &)*arg2);
3815
3816 wxPyEndAllowThreads(__tstate);
3817 if (PyErr_Occurred()) SWIG_fail;
3818 }
3819 Py_INCREF(Py_None); resultobj = Py_None;
3820 return resultobj;
3821 fail:
3822 return NULL;
3823 }
3824
3825
3826 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3827 PyObject *resultobj;
3828 wxBrush *arg1 = (wxBrush *) 0 ;
3829 wxColour result;
3830 PyObject * obj0 = 0 ;
3831 char *kwnames[] = {
3832 (char *) "self", NULL
3833 };
3834
3835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3837 if (SWIG_arg_fail(1)) SWIG_fail;
3838 {
3839 PyThreadState* __tstate = wxPyBeginAllowThreads();
3840 result = ((wxBrush const *)arg1)->GetColour();
3841
3842 wxPyEndAllowThreads(__tstate);
3843 if (PyErr_Occurred()) SWIG_fail;
3844 }
3845 {
3846 wxColour * resultptr;
3847 resultptr = new wxColour((wxColour &)(result));
3848 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3849 }
3850 return resultobj;
3851 fail:
3852 return NULL;
3853 }
3854
3855
3856 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3857 PyObject *resultobj;
3858 wxBrush *arg1 = (wxBrush *) 0 ;
3859 int result;
3860 PyObject * obj0 = 0 ;
3861 char *kwnames[] = {
3862 (char *) "self", NULL
3863 };
3864
3865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3867 if (SWIG_arg_fail(1)) SWIG_fail;
3868 {
3869 PyThreadState* __tstate = wxPyBeginAllowThreads();
3870 result = (int)((wxBrush const *)arg1)->GetStyle();
3871
3872 wxPyEndAllowThreads(__tstate);
3873 if (PyErr_Occurred()) SWIG_fail;
3874 }
3875 {
3876 resultobj = SWIG_From_int((int)(result));
3877 }
3878 return resultobj;
3879 fail:
3880 return NULL;
3881 }
3882
3883
3884 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3885 PyObject *resultobj;
3886 wxBrush *arg1 = (wxBrush *) 0 ;
3887 wxBitmap *result;
3888 PyObject * obj0 = 0 ;
3889 char *kwnames[] = {
3890 (char *) "self", NULL
3891 };
3892
3893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3895 if (SWIG_arg_fail(1)) SWIG_fail;
3896 {
3897 PyThreadState* __tstate = wxPyBeginAllowThreads();
3898 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3899
3900 wxPyEndAllowThreads(__tstate);
3901 if (PyErr_Occurred()) SWIG_fail;
3902 }
3903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3904 return resultobj;
3905 fail:
3906 return NULL;
3907 }
3908
3909
3910 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3911 PyObject *resultobj;
3912 wxBrush *arg1 = (wxBrush *) 0 ;
3913 bool result;
3914 PyObject * obj0 = 0 ;
3915 char *kwnames[] = {
3916 (char *) "self", NULL
3917 };
3918
3919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3921 if (SWIG_arg_fail(1)) SWIG_fail;
3922 {
3923 PyThreadState* __tstate = wxPyBeginAllowThreads();
3924 result = (bool)((wxBrush const *)arg1)->IsHatch();
3925
3926 wxPyEndAllowThreads(__tstate);
3927 if (PyErr_Occurred()) SWIG_fail;
3928 }
3929 {
3930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3931 }
3932 return resultobj;
3933 fail:
3934 return NULL;
3935 }
3936
3937
3938 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3939 PyObject *resultobj;
3940 wxBrush *arg1 = (wxBrush *) 0 ;
3941 bool result;
3942 PyObject * obj0 = 0 ;
3943 char *kwnames[] = {
3944 (char *) "self", NULL
3945 };
3946
3947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3949 if (SWIG_arg_fail(1)) SWIG_fail;
3950 {
3951 PyThreadState* __tstate = wxPyBeginAllowThreads();
3952 result = (bool)(arg1)->Ok();
3953
3954 wxPyEndAllowThreads(__tstate);
3955 if (PyErr_Occurred()) SWIG_fail;
3956 }
3957 {
3958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3959 }
3960 return resultobj;
3961 fail:
3962 return NULL;
3963 }
3964
3965
3966 static PyObject *_wrap_Brush_MacGetTheme(PyObject *, PyObject *args, PyObject *kwargs) {
3967 PyObject *resultobj;
3968 wxBrush *arg1 = (wxBrush *) 0 ;
3969 short result;
3970 PyObject * obj0 = 0 ;
3971 char *kwnames[] = {
3972 (char *) "self", NULL
3973 };
3974
3975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_MacGetTheme",kwnames,&obj0)) goto fail;
3976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3977 if (SWIG_arg_fail(1)) SWIG_fail;
3978 {
3979 PyThreadState* __tstate = wxPyBeginAllowThreads();
3980 result = (short)(arg1)->MacGetTheme();
3981
3982 wxPyEndAllowThreads(__tstate);
3983 if (PyErr_Occurred()) SWIG_fail;
3984 }
3985 {
3986 resultobj = SWIG_From_short((short)(result));
3987 }
3988 return resultobj;
3989 fail:
3990 return NULL;
3991 }
3992
3993
3994 static PyObject *_wrap_Brush_MacSetTheme(PyObject *, PyObject *args, PyObject *kwargs) {
3995 PyObject *resultobj;
3996 wxBrush *arg1 = (wxBrush *) 0 ;
3997 short arg2 ;
3998 PyObject * obj0 = 0 ;
3999 PyObject * obj1 = 0 ;
4000 char *kwnames[] = {
4001 (char *) "self",(char *) "macThemeBrush", NULL
4002 };
4003
4004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_MacSetTheme",kwnames,&obj0,&obj1)) goto fail;
4005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
4006 if (SWIG_arg_fail(1)) SWIG_fail;
4007 {
4008 arg2 = (short)(SWIG_As_short(obj1));
4009 if (SWIG_arg_fail(2)) SWIG_fail;
4010 }
4011 {
4012 PyThreadState* __tstate = wxPyBeginAllowThreads();
4013 (arg1)->MacSetTheme(arg2);
4014
4015 wxPyEndAllowThreads(__tstate);
4016 if (PyErr_Occurred()) SWIG_fail;
4017 }
4018 Py_INCREF(Py_None); resultobj = Py_None;
4019 return resultobj;
4020 fail:
4021 return NULL;
4022 }
4023
4024
4025 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
4026 PyObject *obj;
4027 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4028 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
4029 Py_INCREF(obj);
4030 return Py_BuildValue((char *)"");
4031 }
4032 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4033 PyObject *resultobj;
4034 wxString *arg1 = 0 ;
4035 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
4036 wxBitmap *result;
4037 bool temp1 = false ;
4038 PyObject * obj0 = 0 ;
4039 PyObject * obj1 = 0 ;
4040 char *kwnames[] = {
4041 (char *) "name",(char *) "type", NULL
4042 };
4043
4044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
4045 {
4046 arg1 = wxString_in_helper(obj0);
4047 if (arg1 == NULL) SWIG_fail;
4048 temp1 = true;
4049 }
4050 if (obj1) {
4051 {
4052 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4053 if (SWIG_arg_fail(2)) SWIG_fail;
4054 }
4055 }
4056 {
4057 if (!wxPyCheckForApp()) SWIG_fail;
4058 PyThreadState* __tstate = wxPyBeginAllowThreads();
4059 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
4060
4061 wxPyEndAllowThreads(__tstate);
4062 if (PyErr_Occurred()) SWIG_fail;
4063 }
4064 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4065 {
4066 if (temp1)
4067 delete arg1;
4068 }
4069 return resultobj;
4070 fail:
4071 {
4072 if (temp1)
4073 delete arg1;
4074 }
4075 return NULL;
4076 }
4077
4078
4079 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4080 PyObject *resultobj;
4081 wxBitmap *arg1 = (wxBitmap *) 0 ;
4082 PyObject * obj0 = 0 ;
4083 char *kwnames[] = {
4084 (char *) "self", NULL
4085 };
4086
4087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
4088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4089 if (SWIG_arg_fail(1)) SWIG_fail;
4090 {
4091 PyThreadState* __tstate = wxPyBeginAllowThreads();
4092 delete arg1;
4093
4094 wxPyEndAllowThreads(__tstate);
4095 if (PyErr_Occurred()) SWIG_fail;
4096 }
4097 Py_INCREF(Py_None); resultobj = Py_None;
4098 return resultobj;
4099 fail:
4100 return NULL;
4101 }
4102
4103
4104 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4105 PyObject *resultobj;
4106 int arg1 ;
4107 int arg2 ;
4108 int arg3 = (int) -1 ;
4109 wxBitmap *result;
4110 PyObject * obj0 = 0 ;
4111 PyObject * obj1 = 0 ;
4112 PyObject * obj2 = 0 ;
4113 char *kwnames[] = {
4114 (char *) "width",(char *) "height",(char *) "depth", NULL
4115 };
4116
4117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4118 {
4119 arg1 = (int)(SWIG_As_int(obj0));
4120 if (SWIG_arg_fail(1)) SWIG_fail;
4121 }
4122 {
4123 arg2 = (int)(SWIG_As_int(obj1));
4124 if (SWIG_arg_fail(2)) SWIG_fail;
4125 }
4126 if (obj2) {
4127 {
4128 arg3 = (int)(SWIG_As_int(obj2));
4129 if (SWIG_arg_fail(3)) SWIG_fail;
4130 }
4131 }
4132 {
4133 if (!wxPyCheckForApp()) SWIG_fail;
4134 PyThreadState* __tstate = wxPyBeginAllowThreads();
4135 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4136
4137 wxPyEndAllowThreads(__tstate);
4138 if (PyErr_Occurred()) SWIG_fail;
4139 }
4140 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4141 return resultobj;
4142 fail:
4143 return NULL;
4144 }
4145
4146
4147 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4148 PyObject *resultobj;
4149 wxIcon *arg1 = 0 ;
4150 wxBitmap *result;
4151 PyObject * obj0 = 0 ;
4152 char *kwnames[] = {
4153 (char *) "icon", NULL
4154 };
4155
4156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4157 {
4158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4159 if (SWIG_arg_fail(1)) SWIG_fail;
4160 if (arg1 == NULL) {
4161 SWIG_null_ref("wxIcon");
4162 }
4163 if (SWIG_arg_fail(1)) SWIG_fail;
4164 }
4165 {
4166 if (!wxPyCheckForApp()) SWIG_fail;
4167 PyThreadState* __tstate = wxPyBeginAllowThreads();
4168 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4169
4170 wxPyEndAllowThreads(__tstate);
4171 if (PyErr_Occurred()) SWIG_fail;
4172 }
4173 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4174 return resultobj;
4175 fail:
4176 return NULL;
4177 }
4178
4179
4180 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4181 PyObject *resultobj;
4182 wxImage *arg1 = 0 ;
4183 int arg2 = (int) -1 ;
4184 wxBitmap *result;
4185 PyObject * obj0 = 0 ;
4186 PyObject * obj1 = 0 ;
4187 char *kwnames[] = {
4188 (char *) "image",(char *) "depth", NULL
4189 };
4190
4191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4192 {
4193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4194 if (SWIG_arg_fail(1)) SWIG_fail;
4195 if (arg1 == NULL) {
4196 SWIG_null_ref("wxImage");
4197 }
4198 if (SWIG_arg_fail(1)) SWIG_fail;
4199 }
4200 if (obj1) {
4201 {
4202 arg2 = (int)(SWIG_As_int(obj1));
4203 if (SWIG_arg_fail(2)) SWIG_fail;
4204 }
4205 }
4206 {
4207 if (!wxPyCheckForApp()) SWIG_fail;
4208 PyThreadState* __tstate = wxPyBeginAllowThreads();
4209 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4210
4211 wxPyEndAllowThreads(__tstate);
4212 if (PyErr_Occurred()) SWIG_fail;
4213 }
4214 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4215 return resultobj;
4216 fail:
4217 return NULL;
4218 }
4219
4220
4221 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4222 PyObject *resultobj;
4223 PyObject *arg1 = (PyObject *) 0 ;
4224 wxBitmap *result;
4225 PyObject * obj0 = 0 ;
4226 char *kwnames[] = {
4227 (char *) "listOfStrings", NULL
4228 };
4229
4230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4231 arg1 = obj0;
4232 {
4233 if (!wxPyCheckForApp()) SWIG_fail;
4234 PyThreadState* __tstate = wxPyBeginAllowThreads();
4235 result = (wxBitmap *)new_wxBitmap(arg1);
4236
4237 wxPyEndAllowThreads(__tstate);
4238 if (PyErr_Occurred()) SWIG_fail;
4239 }
4240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4241 return resultobj;
4242 fail:
4243 return NULL;
4244 }
4245
4246
4247 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4248 PyObject *resultobj;
4249 PyObject *arg1 = (PyObject *) 0 ;
4250 int arg2 ;
4251 int arg3 ;
4252 int arg4 = (int) 1 ;
4253 wxBitmap *result;
4254 PyObject * obj0 = 0 ;
4255 PyObject * obj1 = 0 ;
4256 PyObject * obj2 = 0 ;
4257 PyObject * obj3 = 0 ;
4258 char *kwnames[] = {
4259 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4260 };
4261
4262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4263 arg1 = obj0;
4264 {
4265 arg2 = (int)(SWIG_As_int(obj1));
4266 if (SWIG_arg_fail(2)) SWIG_fail;
4267 }
4268 {
4269 arg3 = (int)(SWIG_As_int(obj2));
4270 if (SWIG_arg_fail(3)) SWIG_fail;
4271 }
4272 if (obj3) {
4273 {
4274 arg4 = (int)(SWIG_As_int(obj3));
4275 if (SWIG_arg_fail(4)) SWIG_fail;
4276 }
4277 }
4278 {
4279 if (!wxPyCheckForApp()) SWIG_fail;
4280 PyThreadState* __tstate = wxPyBeginAllowThreads();
4281 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4282
4283 wxPyEndAllowThreads(__tstate);
4284 if (PyErr_Occurred()) SWIG_fail;
4285 }
4286 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4287 return resultobj;
4288 fail:
4289 return NULL;
4290 }
4291
4292
4293 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4294 PyObject *resultobj;
4295 wxBitmap *arg1 = (wxBitmap *) 0 ;
4296 bool result;
4297 PyObject * obj0 = 0 ;
4298 char *kwnames[] = {
4299 (char *) "self", NULL
4300 };
4301
4302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4304 if (SWIG_arg_fail(1)) SWIG_fail;
4305 {
4306 PyThreadState* __tstate = wxPyBeginAllowThreads();
4307 result = (bool)(arg1)->Ok();
4308
4309 wxPyEndAllowThreads(__tstate);
4310 if (PyErr_Occurred()) SWIG_fail;
4311 }
4312 {
4313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4314 }
4315 return resultobj;
4316 fail:
4317 return NULL;
4318 }
4319
4320
4321 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4322 PyObject *resultobj;
4323 wxBitmap *arg1 = (wxBitmap *) 0 ;
4324 int result;
4325 PyObject * obj0 = 0 ;
4326 char *kwnames[] = {
4327 (char *) "self", NULL
4328 };
4329
4330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4332 if (SWIG_arg_fail(1)) SWIG_fail;
4333 {
4334 PyThreadState* __tstate = wxPyBeginAllowThreads();
4335 result = (int)(arg1)->GetWidth();
4336
4337 wxPyEndAllowThreads(__tstate);
4338 if (PyErr_Occurred()) SWIG_fail;
4339 }
4340 {
4341 resultobj = SWIG_From_int((int)(result));
4342 }
4343 return resultobj;
4344 fail:
4345 return NULL;
4346 }
4347
4348
4349 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4350 PyObject *resultobj;
4351 wxBitmap *arg1 = (wxBitmap *) 0 ;
4352 int result;
4353 PyObject * obj0 = 0 ;
4354 char *kwnames[] = {
4355 (char *) "self", NULL
4356 };
4357
4358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4360 if (SWIG_arg_fail(1)) SWIG_fail;
4361 {
4362 PyThreadState* __tstate = wxPyBeginAllowThreads();
4363 result = (int)(arg1)->GetHeight();
4364
4365 wxPyEndAllowThreads(__tstate);
4366 if (PyErr_Occurred()) SWIG_fail;
4367 }
4368 {
4369 resultobj = SWIG_From_int((int)(result));
4370 }
4371 return resultobj;
4372 fail:
4373 return NULL;
4374 }
4375
4376
4377 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4378 PyObject *resultobj;
4379 wxBitmap *arg1 = (wxBitmap *) 0 ;
4380 int result;
4381 PyObject * obj0 = 0 ;
4382 char *kwnames[] = {
4383 (char *) "self", NULL
4384 };
4385
4386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4388 if (SWIG_arg_fail(1)) SWIG_fail;
4389 {
4390 PyThreadState* __tstate = wxPyBeginAllowThreads();
4391 result = (int)(arg1)->GetDepth();
4392
4393 wxPyEndAllowThreads(__tstate);
4394 if (PyErr_Occurred()) SWIG_fail;
4395 }
4396 {
4397 resultobj = SWIG_From_int((int)(result));
4398 }
4399 return resultobj;
4400 fail:
4401 return NULL;
4402 }
4403
4404
4405 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4406 PyObject *resultobj;
4407 wxBitmap *arg1 = (wxBitmap *) 0 ;
4408 wxSize result;
4409 PyObject * obj0 = 0 ;
4410 char *kwnames[] = {
4411 (char *) "self", NULL
4412 };
4413
4414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4416 if (SWIG_arg_fail(1)) SWIG_fail;
4417 {
4418 PyThreadState* __tstate = wxPyBeginAllowThreads();
4419 result = wxBitmap_GetSize(arg1);
4420
4421 wxPyEndAllowThreads(__tstate);
4422 if (PyErr_Occurred()) SWIG_fail;
4423 }
4424 {
4425 wxSize * resultptr;
4426 resultptr = new wxSize((wxSize &)(result));
4427 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4428 }
4429 return resultobj;
4430 fail:
4431 return NULL;
4432 }
4433
4434
4435 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4436 PyObject *resultobj;
4437 wxBitmap *arg1 = (wxBitmap *) 0 ;
4438 SwigValueWrapper<wxImage > result;
4439 PyObject * obj0 = 0 ;
4440 char *kwnames[] = {
4441 (char *) "self", NULL
4442 };
4443
4444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4446 if (SWIG_arg_fail(1)) SWIG_fail;
4447 {
4448 PyThreadState* __tstate = wxPyBeginAllowThreads();
4449 result = ((wxBitmap const *)arg1)->ConvertToImage();
4450
4451 wxPyEndAllowThreads(__tstate);
4452 if (PyErr_Occurred()) SWIG_fail;
4453 }
4454 {
4455 wxImage * resultptr;
4456 resultptr = new wxImage((wxImage &)(result));
4457 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4458 }
4459 return resultobj;
4460 fail:
4461 return NULL;
4462 }
4463
4464
4465 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4466 PyObject *resultobj;
4467 wxBitmap *arg1 = (wxBitmap *) 0 ;
4468 wxMask *result;
4469 PyObject * obj0 = 0 ;
4470 char *kwnames[] = {
4471 (char *) "self", NULL
4472 };
4473
4474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4476 if (SWIG_arg_fail(1)) SWIG_fail;
4477 {
4478 PyThreadState* __tstate = wxPyBeginAllowThreads();
4479 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4480
4481 wxPyEndAllowThreads(__tstate);
4482 if (PyErr_Occurred()) SWIG_fail;
4483 }
4484 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4485 return resultobj;
4486 fail:
4487 return NULL;
4488 }
4489
4490
4491 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4492 PyObject *resultobj;
4493 wxBitmap *arg1 = (wxBitmap *) 0 ;
4494 wxMask *arg2 = (wxMask *) 0 ;
4495 PyObject * obj0 = 0 ;
4496 PyObject * obj1 = 0 ;
4497 char *kwnames[] = {
4498 (char *) "self",(char *) "mask", NULL
4499 };
4500
4501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4503 if (SWIG_arg_fail(1)) SWIG_fail;
4504 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4505 if (SWIG_arg_fail(2)) SWIG_fail;
4506 {
4507 PyThreadState* __tstate = wxPyBeginAllowThreads();
4508 (arg1)->SetMask(arg2);
4509
4510 wxPyEndAllowThreads(__tstate);
4511 if (PyErr_Occurred()) SWIG_fail;
4512 }
4513 Py_INCREF(Py_None); resultobj = Py_None;
4514 return resultobj;
4515 fail:
4516 return NULL;
4517 }
4518
4519
4520 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4521 PyObject *resultobj;
4522 wxBitmap *arg1 = (wxBitmap *) 0 ;
4523 wxColour *arg2 = 0 ;
4524 wxColour temp2 ;
4525 PyObject * obj0 = 0 ;
4526 PyObject * obj1 = 0 ;
4527 char *kwnames[] = {
4528 (char *) "self",(char *) "colour", NULL
4529 };
4530
4531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4533 if (SWIG_arg_fail(1)) SWIG_fail;
4534 {
4535 arg2 = &temp2;
4536 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4537 }
4538 {
4539 PyThreadState* __tstate = wxPyBeginAllowThreads();
4540 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4541
4542 wxPyEndAllowThreads(__tstate);
4543 if (PyErr_Occurred()) SWIG_fail;
4544 }
4545 Py_INCREF(Py_None); resultobj = Py_None;
4546 return resultobj;
4547 fail:
4548 return NULL;
4549 }
4550
4551
4552 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4553 PyObject *resultobj;
4554 wxBitmap *arg1 = (wxBitmap *) 0 ;
4555 wxRect *arg2 = 0 ;
4556 SwigValueWrapper<wxBitmap > result;
4557 wxRect temp2 ;
4558 PyObject * obj0 = 0 ;
4559 PyObject * obj1 = 0 ;
4560 char *kwnames[] = {
4561 (char *) "self",(char *) "rect", NULL
4562 };
4563
4564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4566 if (SWIG_arg_fail(1)) SWIG_fail;
4567 {
4568 arg2 = &temp2;
4569 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4570 }
4571 {
4572 PyThreadState* __tstate = wxPyBeginAllowThreads();
4573 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4574
4575 wxPyEndAllowThreads(__tstate);
4576 if (PyErr_Occurred()) SWIG_fail;
4577 }
4578 {
4579 wxBitmap * resultptr;
4580 resultptr = new wxBitmap((wxBitmap &)(result));
4581 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4582 }
4583 return resultobj;
4584 fail:
4585 return NULL;
4586 }
4587
4588
4589 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4590 PyObject *resultobj;
4591 wxBitmap *arg1 = (wxBitmap *) 0 ;
4592 wxString *arg2 = 0 ;
4593 wxBitmapType arg3 ;
4594 wxPalette *arg4 = (wxPalette *) NULL ;
4595 bool result;
4596 bool temp2 = false ;
4597 PyObject * obj0 = 0 ;
4598 PyObject * obj1 = 0 ;
4599 PyObject * obj2 = 0 ;
4600 PyObject * obj3 = 0 ;
4601 char *kwnames[] = {
4602 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4603 };
4604
4605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4607 if (SWIG_arg_fail(1)) SWIG_fail;
4608 {
4609 arg2 = wxString_in_helper(obj1);
4610 if (arg2 == NULL) SWIG_fail;
4611 temp2 = true;
4612 }
4613 {
4614 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4615 if (SWIG_arg_fail(3)) SWIG_fail;
4616 }
4617 if (obj3) {
4618 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4619 if (SWIG_arg_fail(4)) SWIG_fail;
4620 }
4621 {
4622 PyThreadState* __tstate = wxPyBeginAllowThreads();
4623 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4624
4625 wxPyEndAllowThreads(__tstate);
4626 if (PyErr_Occurred()) SWIG_fail;
4627 }
4628 {
4629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4630 }
4631 {
4632 if (temp2)
4633 delete arg2;
4634 }
4635 return resultobj;
4636 fail:
4637 {
4638 if (temp2)
4639 delete arg2;
4640 }
4641 return NULL;
4642 }
4643
4644
4645 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4646 PyObject *resultobj;
4647 wxBitmap *arg1 = (wxBitmap *) 0 ;
4648 wxString *arg2 = 0 ;
4649 wxBitmapType arg3 ;
4650 bool result;
4651 bool temp2 = false ;
4652 PyObject * obj0 = 0 ;
4653 PyObject * obj1 = 0 ;
4654 PyObject * obj2 = 0 ;
4655 char *kwnames[] = {
4656 (char *) "self",(char *) "name",(char *) "type", NULL
4657 };
4658
4659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4661 if (SWIG_arg_fail(1)) SWIG_fail;
4662 {
4663 arg2 = wxString_in_helper(obj1);
4664 if (arg2 == NULL) SWIG_fail;
4665 temp2 = true;
4666 }
4667 {
4668 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4669 if (SWIG_arg_fail(3)) SWIG_fail;
4670 }
4671 {
4672 PyThreadState* __tstate = wxPyBeginAllowThreads();
4673 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4674
4675 wxPyEndAllowThreads(__tstate);
4676 if (PyErr_Occurred()) SWIG_fail;
4677 }
4678 {
4679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4680 }
4681 {
4682 if (temp2)
4683 delete arg2;
4684 }
4685 return resultobj;
4686 fail:
4687 {
4688 if (temp2)
4689 delete arg2;
4690 }
4691 return NULL;
4692 }
4693
4694
4695 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4696 PyObject *resultobj;
4697 wxBitmap *arg1 = (wxBitmap *) 0 ;
4698 wxPalette *result;
4699 PyObject * obj0 = 0 ;
4700 char *kwnames[] = {
4701 (char *) "self", NULL
4702 };
4703
4704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4706 if (SWIG_arg_fail(1)) SWIG_fail;
4707 {
4708 PyThreadState* __tstate = wxPyBeginAllowThreads();
4709 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4710
4711 wxPyEndAllowThreads(__tstate);
4712 if (PyErr_Occurred()) SWIG_fail;
4713 }
4714 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4715 return resultobj;
4716 fail:
4717 return NULL;
4718 }
4719
4720
4721 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4722 PyObject *resultobj;
4723 wxBitmap *arg1 = (wxBitmap *) 0 ;
4724 wxIcon *arg2 = 0 ;
4725 bool result;
4726 PyObject * obj0 = 0 ;
4727 PyObject * obj1 = 0 ;
4728 char *kwnames[] = {
4729 (char *) "self",(char *) "icon", NULL
4730 };
4731
4732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4734 if (SWIG_arg_fail(1)) SWIG_fail;
4735 {
4736 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4737 if (SWIG_arg_fail(2)) SWIG_fail;
4738 if (arg2 == NULL) {
4739 SWIG_null_ref("wxIcon");
4740 }
4741 if (SWIG_arg_fail(2)) SWIG_fail;
4742 }
4743 {
4744 PyThreadState* __tstate = wxPyBeginAllowThreads();
4745 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4746
4747 wxPyEndAllowThreads(__tstate);
4748 if (PyErr_Occurred()) SWIG_fail;
4749 }
4750 {
4751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4752 }
4753 return resultobj;
4754 fail:
4755 return NULL;
4756 }
4757
4758
4759 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4760 PyObject *resultobj;
4761 wxBitmap *arg1 = (wxBitmap *) 0 ;
4762 int arg2 ;
4763 PyObject * obj0 = 0 ;
4764 PyObject * obj1 = 0 ;
4765 char *kwnames[] = {
4766 (char *) "self",(char *) "height", NULL
4767 };
4768
4769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4771 if (SWIG_arg_fail(1)) SWIG_fail;
4772 {
4773 arg2 = (int)(SWIG_As_int(obj1));
4774 if (SWIG_arg_fail(2)) SWIG_fail;
4775 }
4776 {
4777 PyThreadState* __tstate = wxPyBeginAllowThreads();
4778 (arg1)->SetHeight(arg2);
4779
4780 wxPyEndAllowThreads(__tstate);
4781 if (PyErr_Occurred()) SWIG_fail;
4782 }
4783 Py_INCREF(Py_None); resultobj = Py_None;
4784 return resultobj;
4785 fail:
4786 return NULL;
4787 }
4788
4789
4790 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4791 PyObject *resultobj;
4792 wxBitmap *arg1 = (wxBitmap *) 0 ;
4793 int arg2 ;
4794 PyObject * obj0 = 0 ;
4795 PyObject * obj1 = 0 ;
4796 char *kwnames[] = {
4797 (char *) "self",(char *) "width", NULL
4798 };
4799
4800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4802 if (SWIG_arg_fail(1)) SWIG_fail;
4803 {
4804 arg2 = (int)(SWIG_As_int(obj1));
4805 if (SWIG_arg_fail(2)) SWIG_fail;
4806 }
4807 {
4808 PyThreadState* __tstate = wxPyBeginAllowThreads();
4809 (arg1)->SetWidth(arg2);
4810
4811 wxPyEndAllowThreads(__tstate);
4812 if (PyErr_Occurred()) SWIG_fail;
4813 }
4814 Py_INCREF(Py_None); resultobj = Py_None;
4815 return resultobj;
4816 fail:
4817 return NULL;
4818 }
4819
4820
4821 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4822 PyObject *resultobj;
4823 wxBitmap *arg1 = (wxBitmap *) 0 ;
4824 int arg2 ;
4825 PyObject * obj0 = 0 ;
4826 PyObject * obj1 = 0 ;
4827 char *kwnames[] = {
4828 (char *) "self",(char *) "depth", NULL
4829 };
4830
4831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4833 if (SWIG_arg_fail(1)) SWIG_fail;
4834 {
4835 arg2 = (int)(SWIG_As_int(obj1));
4836 if (SWIG_arg_fail(2)) SWIG_fail;
4837 }
4838 {
4839 PyThreadState* __tstate = wxPyBeginAllowThreads();
4840 (arg1)->SetDepth(arg2);
4841
4842 wxPyEndAllowThreads(__tstate);
4843 if (PyErr_Occurred()) SWIG_fail;
4844 }
4845 Py_INCREF(Py_None); resultobj = Py_None;
4846 return resultobj;
4847 fail:
4848 return NULL;
4849 }
4850
4851
4852 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4853 PyObject *resultobj;
4854 wxBitmap *arg1 = (wxBitmap *) 0 ;
4855 wxSize *arg2 = 0 ;
4856 wxSize temp2 ;
4857 PyObject * obj0 = 0 ;
4858 PyObject * obj1 = 0 ;
4859 char *kwnames[] = {
4860 (char *) "self",(char *) "size", NULL
4861 };
4862
4863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4865 if (SWIG_arg_fail(1)) SWIG_fail;
4866 {
4867 arg2 = &temp2;
4868 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4869 }
4870 {
4871 PyThreadState* __tstate = wxPyBeginAllowThreads();
4872 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4873
4874 wxPyEndAllowThreads(__tstate);
4875 if (PyErr_Occurred()) SWIG_fail;
4876 }
4877 Py_INCREF(Py_None); resultobj = Py_None;
4878 return resultobj;
4879 fail:
4880 return NULL;
4881 }
4882
4883
4884 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4885 PyObject *resultobj;
4886 wxBitmap *arg1 = (wxBitmap *) 0 ;
4887 wxBitmap *arg2 = (wxBitmap *) 0 ;
4888 bool result;
4889 PyObject * obj0 = 0 ;
4890 PyObject * obj1 = 0 ;
4891 char *kwnames[] = {
4892 (char *) "self",(char *) "other", NULL
4893 };
4894
4895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
4896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4897 if (SWIG_arg_fail(1)) SWIG_fail;
4898 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4899 if (SWIG_arg_fail(2)) SWIG_fail;
4900 {
4901 PyThreadState* __tstate = wxPyBeginAllowThreads();
4902 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
4903
4904 wxPyEndAllowThreads(__tstate);
4905 if (PyErr_Occurred()) SWIG_fail;
4906 }
4907 {
4908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4909 }
4910 return resultobj;
4911 fail:
4912 return NULL;
4913 }
4914
4915
4916 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4917 PyObject *resultobj;
4918 wxBitmap *arg1 = (wxBitmap *) 0 ;
4919 wxBitmap *arg2 = (wxBitmap *) 0 ;
4920 bool result;
4921 PyObject * obj0 = 0 ;
4922 PyObject * obj1 = 0 ;
4923 char *kwnames[] = {
4924 (char *) "self",(char *) "other", NULL
4925 };
4926
4927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
4928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4929 if (SWIG_arg_fail(1)) SWIG_fail;
4930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4931 if (SWIG_arg_fail(2)) SWIG_fail;
4932 {
4933 PyThreadState* __tstate = wxPyBeginAllowThreads();
4934 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
4935
4936 wxPyEndAllowThreads(__tstate);
4937 if (PyErr_Occurred()) SWIG_fail;
4938 }
4939 {
4940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4941 }
4942 return resultobj;
4943 fail:
4944 return NULL;
4945 }
4946
4947
4948 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
4949 PyObject *obj;
4950 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4951 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
4952 Py_INCREF(obj);
4953 return Py_BuildValue((char *)"");
4954 }
4955 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
4956 PyObject *resultobj;
4957 wxBitmap *arg1 = 0 ;
4958 wxColour const &arg2_defvalue = wxNullColour ;
4959 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
4960 wxMask *result;
4961 wxColour temp2 ;
4962 PyObject * obj0 = 0 ;
4963 PyObject * obj1 = 0 ;
4964 char *kwnames[] = {
4965 (char *) "bitmap",(char *) "colour", NULL
4966 };
4967
4968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
4969 {
4970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4971 if (SWIG_arg_fail(1)) SWIG_fail;
4972 if (arg1 == NULL) {
4973 SWIG_null_ref("wxBitmap");
4974 }
4975 if (SWIG_arg_fail(1)) SWIG_fail;
4976 }
4977 if (obj1) {
4978 {
4979 arg2 = &temp2;
4980 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4981 }
4982 }
4983 {
4984 if (!wxPyCheckForApp()) SWIG_fail;
4985 PyThreadState* __tstate = wxPyBeginAllowThreads();
4986 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
4987
4988 wxPyEndAllowThreads(__tstate);
4989 if (PyErr_Occurred()) SWIG_fail;
4990 }
4991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
4992 return resultobj;
4993 fail:
4994 return NULL;
4995 }
4996
4997
4998 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
4999 PyObject *obj;
5000 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5001 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
5002 Py_INCREF(obj);
5003 return Py_BuildValue((char *)"");
5004 }
5005 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5006 PyObject *resultobj;
5007 wxString *arg1 = 0 ;
5008 wxBitmapType arg2 ;
5009 int arg3 = (int) -1 ;
5010 int arg4 = (int) -1 ;
5011 wxIcon *result;
5012 bool temp1 = false ;
5013 PyObject * obj0 = 0 ;
5014 PyObject * obj1 = 0 ;
5015 PyObject * obj2 = 0 ;
5016 PyObject * obj3 = 0 ;
5017 char *kwnames[] = {
5018 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
5019 };
5020
5021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5022 {
5023 arg1 = wxString_in_helper(obj0);
5024 if (arg1 == NULL) SWIG_fail;
5025 temp1 = true;
5026 }
5027 {
5028 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
5029 if (SWIG_arg_fail(2)) SWIG_fail;
5030 }
5031 if (obj2) {
5032 {
5033 arg3 = (int)(SWIG_As_int(obj2));
5034 if (SWIG_arg_fail(3)) SWIG_fail;
5035 }
5036 }
5037 if (obj3) {
5038 {
5039 arg4 = (int)(SWIG_As_int(obj3));
5040 if (SWIG_arg_fail(4)) SWIG_fail;
5041 }
5042 }
5043 {
5044 if (!wxPyCheckForApp()) SWIG_fail;
5045 PyThreadState* __tstate = wxPyBeginAllowThreads();
5046 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
5047
5048 wxPyEndAllowThreads(__tstate);
5049 if (PyErr_Occurred()) SWIG_fail;
5050 }
5051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5052 {
5053 if (temp1)
5054 delete arg1;
5055 }
5056 return resultobj;
5057 fail:
5058 {
5059 if (temp1)
5060 delete arg1;
5061 }
5062 return NULL;
5063 }
5064
5065
5066 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5067 PyObject *resultobj;
5068 wxIcon *arg1 = (wxIcon *) 0 ;
5069 PyObject * obj0 = 0 ;
5070 char *kwnames[] = {
5071 (char *) "self", NULL
5072 };
5073
5074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
5075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5076 if (SWIG_arg_fail(1)) SWIG_fail;
5077 {
5078 PyThreadState* __tstate = wxPyBeginAllowThreads();
5079 delete arg1;
5080
5081 wxPyEndAllowThreads(__tstate);
5082 if (PyErr_Occurred()) SWIG_fail;
5083 }
5084 Py_INCREF(Py_None); resultobj = Py_None;
5085 return resultobj;
5086 fail:
5087 return NULL;
5088 }
5089
5090
5091 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5092 PyObject *resultobj;
5093 wxIcon *result;
5094 char *kwnames[] = {
5095 NULL
5096 };
5097
5098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5099 {
5100 if (!wxPyCheckForApp()) SWIG_fail;
5101 PyThreadState* __tstate = wxPyBeginAllowThreads();
5102 result = (wxIcon *)new wxIcon();
5103
5104 wxPyEndAllowThreads(__tstate);
5105 if (PyErr_Occurred()) SWIG_fail;
5106 }
5107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5108 return resultobj;
5109 fail:
5110 return NULL;
5111 }
5112
5113
5114 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5115 PyObject *resultobj;
5116 wxIconLocation *arg1 = 0 ;
5117 wxIcon *result;
5118 PyObject * obj0 = 0 ;
5119 char *kwnames[] = {
5120 (char *) "loc", NULL
5121 };
5122
5123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5124 {
5125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5126 if (SWIG_arg_fail(1)) SWIG_fail;
5127 if (arg1 == NULL) {
5128 SWIG_null_ref("wxIconLocation");
5129 }
5130 if (SWIG_arg_fail(1)) SWIG_fail;
5131 }
5132 {
5133 if (!wxPyCheckForApp()) SWIG_fail;
5134 PyThreadState* __tstate = wxPyBeginAllowThreads();
5135 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5136
5137 wxPyEndAllowThreads(__tstate);
5138 if (PyErr_Occurred()) SWIG_fail;
5139 }
5140 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5141 return resultobj;
5142 fail:
5143 return NULL;
5144 }
5145
5146
5147 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5148 PyObject *resultobj;
5149 wxBitmap *arg1 = 0 ;
5150 wxIcon *result;
5151 PyObject * obj0 = 0 ;
5152 char *kwnames[] = {
5153 (char *) "bmp", NULL
5154 };
5155
5156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5157 {
5158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5159 if (SWIG_arg_fail(1)) SWIG_fail;
5160 if (arg1 == NULL) {
5161 SWIG_null_ref("wxBitmap");
5162 }
5163 if (SWIG_arg_fail(1)) SWIG_fail;
5164 }
5165 {
5166 if (!wxPyCheckForApp()) SWIG_fail;
5167 PyThreadState* __tstate = wxPyBeginAllowThreads();
5168 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5169
5170 wxPyEndAllowThreads(__tstate);
5171 if (PyErr_Occurred()) SWIG_fail;
5172 }
5173 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5174 return resultobj;
5175 fail:
5176 return NULL;
5177 }
5178
5179
5180 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5181 PyObject *resultobj;
5182 PyObject *arg1 = (PyObject *) 0 ;
5183 wxIcon *result;
5184 PyObject * obj0 = 0 ;
5185 char *kwnames[] = {
5186 (char *) "listOfStrings", NULL
5187 };
5188
5189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5190 arg1 = obj0;
5191 {
5192 if (!wxPyCheckForApp()) SWIG_fail;
5193 PyThreadState* __tstate = wxPyBeginAllowThreads();
5194 result = (wxIcon *)new_wxIcon(arg1);
5195
5196 wxPyEndAllowThreads(__tstate);
5197 if (PyErr_Occurred()) SWIG_fail;
5198 }
5199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5200 return resultobj;
5201 fail:
5202 return NULL;
5203 }
5204
5205
5206 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5207 PyObject *resultobj;
5208 wxIcon *arg1 = (wxIcon *) 0 ;
5209 bool result;
5210 PyObject * obj0 = 0 ;
5211 char *kwnames[] = {
5212 (char *) "self", NULL
5213 };
5214
5215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5217 if (SWIG_arg_fail(1)) SWIG_fail;
5218 {
5219 PyThreadState* __tstate = wxPyBeginAllowThreads();
5220 result = (bool)(arg1)->Ok();
5221
5222 wxPyEndAllowThreads(__tstate);
5223 if (PyErr_Occurred()) SWIG_fail;
5224 }
5225 {
5226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5227 }
5228 return resultobj;
5229 fail:
5230 return NULL;
5231 }
5232
5233
5234 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5235 PyObject *resultobj;
5236 wxIcon *arg1 = (wxIcon *) 0 ;
5237 int result;
5238 PyObject * obj0 = 0 ;
5239 char *kwnames[] = {
5240 (char *) "self", NULL
5241 };
5242
5243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5245 if (SWIG_arg_fail(1)) SWIG_fail;
5246 {
5247 PyThreadState* __tstate = wxPyBeginAllowThreads();
5248 result = (int)(arg1)->GetWidth();
5249
5250 wxPyEndAllowThreads(__tstate);
5251 if (PyErr_Occurred()) SWIG_fail;
5252 }
5253 {
5254 resultobj = SWIG_From_int((int)(result));
5255 }
5256 return resultobj;
5257 fail:
5258 return NULL;
5259 }
5260
5261
5262 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5263 PyObject *resultobj;
5264 wxIcon *arg1 = (wxIcon *) 0 ;
5265 int result;
5266 PyObject * obj0 = 0 ;
5267 char *kwnames[] = {
5268 (char *) "self", NULL
5269 };
5270
5271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5273 if (SWIG_arg_fail(1)) SWIG_fail;
5274 {
5275 PyThreadState* __tstate = wxPyBeginAllowThreads();
5276 result = (int)(arg1)->GetHeight();
5277
5278 wxPyEndAllowThreads(__tstate);
5279 if (PyErr_Occurred()) SWIG_fail;
5280 }
5281 {
5282 resultobj = SWIG_From_int((int)(result));
5283 }
5284 return resultobj;
5285 fail:
5286 return NULL;
5287 }
5288
5289
5290 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5291 PyObject *resultobj;
5292 wxIcon *arg1 = (wxIcon *) 0 ;
5293 int result;
5294 PyObject * obj0 = 0 ;
5295 char *kwnames[] = {
5296 (char *) "self", NULL
5297 };
5298
5299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5301 if (SWIG_arg_fail(1)) SWIG_fail;
5302 {
5303 PyThreadState* __tstate = wxPyBeginAllowThreads();
5304 result = (int)(arg1)->GetDepth();
5305
5306 wxPyEndAllowThreads(__tstate);
5307 if (PyErr_Occurred()) SWIG_fail;
5308 }
5309 {
5310 resultobj = SWIG_From_int((int)(result));
5311 }
5312 return resultobj;
5313 fail:
5314 return NULL;
5315 }
5316
5317
5318 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5319 PyObject *resultobj;
5320 wxIcon *arg1 = (wxIcon *) 0 ;
5321 int arg2 ;
5322 PyObject * obj0 = 0 ;
5323 PyObject * obj1 = 0 ;
5324 char *kwnames[] = {
5325 (char *) "self",(char *) "w", NULL
5326 };
5327
5328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5330 if (SWIG_arg_fail(1)) SWIG_fail;
5331 {
5332 arg2 = (int)(SWIG_As_int(obj1));
5333 if (SWIG_arg_fail(2)) SWIG_fail;
5334 }
5335 {
5336 PyThreadState* __tstate = wxPyBeginAllowThreads();
5337 (arg1)->SetWidth(arg2);
5338
5339 wxPyEndAllowThreads(__tstate);
5340 if (PyErr_Occurred()) SWIG_fail;
5341 }
5342 Py_INCREF(Py_None); resultobj = Py_None;
5343 return resultobj;
5344 fail:
5345 return NULL;
5346 }
5347
5348
5349 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5350 PyObject *resultobj;
5351 wxIcon *arg1 = (wxIcon *) 0 ;
5352 int arg2 ;
5353 PyObject * obj0 = 0 ;
5354 PyObject * obj1 = 0 ;
5355 char *kwnames[] = {
5356 (char *) "self",(char *) "h", NULL
5357 };
5358
5359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5361 if (SWIG_arg_fail(1)) SWIG_fail;
5362 {
5363 arg2 = (int)(SWIG_As_int(obj1));
5364 if (SWIG_arg_fail(2)) SWIG_fail;
5365 }
5366 {
5367 PyThreadState* __tstate = wxPyBeginAllowThreads();
5368 (arg1)->SetHeight(arg2);
5369
5370 wxPyEndAllowThreads(__tstate);
5371 if (PyErr_Occurred()) SWIG_fail;
5372 }
5373 Py_INCREF(Py_None); resultobj = Py_None;
5374 return resultobj;
5375 fail:
5376 return NULL;
5377 }
5378
5379
5380 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5381 PyObject *resultobj;
5382 wxIcon *arg1 = (wxIcon *) 0 ;
5383 int arg2 ;
5384 PyObject * obj0 = 0 ;
5385 PyObject * obj1 = 0 ;
5386 char *kwnames[] = {
5387 (char *) "self",(char *) "d", NULL
5388 };
5389
5390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5392 if (SWIG_arg_fail(1)) SWIG_fail;
5393 {
5394 arg2 = (int)(SWIG_As_int(obj1));
5395 if (SWIG_arg_fail(2)) SWIG_fail;
5396 }
5397 {
5398 PyThreadState* __tstate = wxPyBeginAllowThreads();
5399 (arg1)->SetDepth(arg2);
5400
5401 wxPyEndAllowThreads(__tstate);
5402 if (PyErr_Occurred()) SWIG_fail;
5403 }
5404 Py_INCREF(Py_None); resultobj = Py_None;
5405 return resultobj;
5406 fail:
5407 return NULL;
5408 }
5409
5410
5411 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5412 PyObject *resultobj;
5413 wxIcon *arg1 = (wxIcon *) 0 ;
5414 wxBitmap *arg2 = 0 ;
5415 PyObject * obj0 = 0 ;
5416 PyObject * obj1 = 0 ;
5417 char *kwnames[] = {
5418 (char *) "self",(char *) "bmp", NULL
5419 };
5420
5421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5423 if (SWIG_arg_fail(1)) SWIG_fail;
5424 {
5425 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5426 if (SWIG_arg_fail(2)) SWIG_fail;
5427 if (arg2 == NULL) {
5428 SWIG_null_ref("wxBitmap");
5429 }
5430 if (SWIG_arg_fail(2)) SWIG_fail;
5431 }
5432 {
5433 PyThreadState* __tstate = wxPyBeginAllowThreads();
5434 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5435
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 Py_INCREF(Py_None); resultobj = Py_None;
5440 return resultobj;
5441 fail:
5442 return NULL;
5443 }
5444
5445
5446 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5447 PyObject *obj;
5448 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5449 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5450 Py_INCREF(obj);
5451 return Py_BuildValue((char *)"");
5452 }
5453 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5454 PyObject *resultobj;
5455 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5456 int arg2 = (int) 0 ;
5457 wxIconLocation *result;
5458 bool temp1 = false ;
5459 PyObject * obj0 = 0 ;
5460 PyObject * obj1 = 0 ;
5461 char *kwnames[] = {
5462 (char *) "filename",(char *) "num", NULL
5463 };
5464
5465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5466 if (obj0) {
5467 {
5468 arg1 = wxString_in_helper(obj0);
5469 if (arg1 == NULL) SWIG_fail;
5470 temp1 = true;
5471 }
5472 }
5473 if (obj1) {
5474 {
5475 arg2 = (int)(SWIG_As_int(obj1));
5476 if (SWIG_arg_fail(2)) SWIG_fail;
5477 }
5478 }
5479 {
5480 PyThreadState* __tstate = wxPyBeginAllowThreads();
5481 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5482
5483 wxPyEndAllowThreads(__tstate);
5484 if (PyErr_Occurred()) SWIG_fail;
5485 }
5486 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5487 {
5488 if (temp1)
5489 delete arg1;
5490 }
5491 return resultobj;
5492 fail:
5493 {
5494 if (temp1)
5495 delete arg1;
5496 }
5497 return NULL;
5498 }
5499
5500
5501 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5502 PyObject *resultobj;
5503 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5504 PyObject * obj0 = 0 ;
5505 char *kwnames[] = {
5506 (char *) "self", NULL
5507 };
5508
5509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5511 if (SWIG_arg_fail(1)) SWIG_fail;
5512 {
5513 PyThreadState* __tstate = wxPyBeginAllowThreads();
5514 delete arg1;
5515
5516 wxPyEndAllowThreads(__tstate);
5517 if (PyErr_Occurred()) SWIG_fail;
5518 }
5519 Py_INCREF(Py_None); resultobj = Py_None;
5520 return resultobj;
5521 fail:
5522 return NULL;
5523 }
5524
5525
5526 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5527 PyObject *resultobj;
5528 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5529 bool result;
5530 PyObject * obj0 = 0 ;
5531 char *kwnames[] = {
5532 (char *) "self", NULL
5533 };
5534
5535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5537 if (SWIG_arg_fail(1)) SWIG_fail;
5538 {
5539 PyThreadState* __tstate = wxPyBeginAllowThreads();
5540 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5541
5542 wxPyEndAllowThreads(__tstate);
5543 if (PyErr_Occurred()) SWIG_fail;
5544 }
5545 {
5546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5547 }
5548 return resultobj;
5549 fail:
5550 return NULL;
5551 }
5552
5553
5554 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5555 PyObject *resultobj;
5556 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5557 wxString *arg2 = 0 ;
5558 bool temp2 = false ;
5559 PyObject * obj0 = 0 ;
5560 PyObject * obj1 = 0 ;
5561 char *kwnames[] = {
5562 (char *) "self",(char *) "filename", NULL
5563 };
5564
5565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5567 if (SWIG_arg_fail(1)) SWIG_fail;
5568 {
5569 arg2 = wxString_in_helper(obj1);
5570 if (arg2 == NULL) SWIG_fail;
5571 temp2 = true;
5572 }
5573 {
5574 PyThreadState* __tstate = wxPyBeginAllowThreads();
5575 (arg1)->SetFileName((wxString const &)*arg2);
5576
5577 wxPyEndAllowThreads(__tstate);
5578 if (PyErr_Occurred()) SWIG_fail;
5579 }
5580 Py_INCREF(Py_None); resultobj = Py_None;
5581 {
5582 if (temp2)
5583 delete arg2;
5584 }
5585 return resultobj;
5586 fail:
5587 {
5588 if (temp2)
5589 delete arg2;
5590 }
5591 return NULL;
5592 }
5593
5594
5595 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5596 PyObject *resultobj;
5597 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5598 wxString *result;
5599 PyObject * obj0 = 0 ;
5600 char *kwnames[] = {
5601 (char *) "self", NULL
5602 };
5603
5604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5606 if (SWIG_arg_fail(1)) SWIG_fail;
5607 {
5608 PyThreadState* __tstate = wxPyBeginAllowThreads();
5609 {
5610 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5611 result = (wxString *) &_result_ref;
5612 }
5613
5614 wxPyEndAllowThreads(__tstate);
5615 if (PyErr_Occurred()) SWIG_fail;
5616 }
5617 {
5618 #if wxUSE_UNICODE
5619 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5620 #else
5621 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5622 #endif
5623 }
5624 return resultobj;
5625 fail:
5626 return NULL;
5627 }
5628
5629
5630 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5631 PyObject *resultobj;
5632 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5633 int arg2 ;
5634 PyObject * obj0 = 0 ;
5635 PyObject * obj1 = 0 ;
5636 char *kwnames[] = {
5637 (char *) "self",(char *) "num", NULL
5638 };
5639
5640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5642 if (SWIG_arg_fail(1)) SWIG_fail;
5643 {
5644 arg2 = (int)(SWIG_As_int(obj1));
5645 if (SWIG_arg_fail(2)) SWIG_fail;
5646 }
5647 {
5648 PyThreadState* __tstate = wxPyBeginAllowThreads();
5649 wxIconLocation_SetIndex(arg1,arg2);
5650
5651 wxPyEndAllowThreads(__tstate);
5652 if (PyErr_Occurred()) SWIG_fail;
5653 }
5654 Py_INCREF(Py_None); resultobj = Py_None;
5655 return resultobj;
5656 fail:
5657 return NULL;
5658 }
5659
5660
5661 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5662 PyObject *resultobj;
5663 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5664 int result;
5665 PyObject * obj0 = 0 ;
5666 char *kwnames[] = {
5667 (char *) "self", NULL
5668 };
5669
5670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5672 if (SWIG_arg_fail(1)) SWIG_fail;
5673 {
5674 PyThreadState* __tstate = wxPyBeginAllowThreads();
5675 result = (int)wxIconLocation_GetIndex(arg1);
5676
5677 wxPyEndAllowThreads(__tstate);
5678 if (PyErr_Occurred()) SWIG_fail;
5679 }
5680 {
5681 resultobj = SWIG_From_int((int)(result));
5682 }
5683 return resultobj;
5684 fail:
5685 return NULL;
5686 }
5687
5688
5689 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5690 PyObject *obj;
5691 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5692 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5693 Py_INCREF(obj);
5694 return Py_BuildValue((char *)"");
5695 }
5696 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5697 PyObject *resultobj;
5698 wxIconBundle *result;
5699 char *kwnames[] = {
5700 NULL
5701 };
5702
5703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5704 {
5705 PyThreadState* __tstate = wxPyBeginAllowThreads();
5706 result = (wxIconBundle *)new wxIconBundle();
5707
5708 wxPyEndAllowThreads(__tstate);
5709 if (PyErr_Occurred()) SWIG_fail;
5710 }
5711 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5712 return resultobj;
5713 fail:
5714 return NULL;
5715 }
5716
5717
5718 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5719 PyObject *resultobj;
5720 wxString *arg1 = 0 ;
5721 long arg2 ;
5722 wxIconBundle *result;
5723 bool temp1 = false ;
5724 PyObject * obj0 = 0 ;
5725 PyObject * obj1 = 0 ;
5726 char *kwnames[] = {
5727 (char *) "file",(char *) "type", NULL
5728 };
5729
5730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
5731 {
5732 arg1 = wxString_in_helper(obj0);
5733 if (arg1 == NULL) SWIG_fail;
5734 temp1 = true;
5735 }
5736 {
5737 arg2 = (long)(SWIG_As_long(obj1));
5738 if (SWIG_arg_fail(2)) SWIG_fail;
5739 }
5740 {
5741 PyThreadState* __tstate = wxPyBeginAllowThreads();
5742 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
5743
5744 wxPyEndAllowThreads(__tstate);
5745 if (PyErr_Occurred()) SWIG_fail;
5746 }
5747 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5748 {
5749 if (temp1)
5750 delete arg1;
5751 }
5752 return resultobj;
5753 fail:
5754 {
5755 if (temp1)
5756 delete arg1;
5757 }
5758 return NULL;
5759 }
5760
5761
5762 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5763 PyObject *resultobj;
5764 wxIcon *arg1 = 0 ;
5765 wxIconBundle *result;
5766 PyObject * obj0 = 0 ;
5767 char *kwnames[] = {
5768 (char *) "icon", NULL
5769 };
5770
5771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
5772 {
5773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5774 if (SWIG_arg_fail(1)) SWIG_fail;
5775 if (arg1 == NULL) {
5776 SWIG_null_ref("wxIcon");
5777 }
5778 if (SWIG_arg_fail(1)) SWIG_fail;
5779 }
5780 {
5781 PyThreadState* __tstate = wxPyBeginAllowThreads();
5782 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
5783
5784 wxPyEndAllowThreads(__tstate);
5785 if (PyErr_Occurred()) SWIG_fail;
5786 }
5787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5788 return resultobj;
5789 fail:
5790 return NULL;
5791 }
5792
5793
5794 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5795 PyObject *resultobj;
5796 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5797 PyObject * obj0 = 0 ;
5798 char *kwnames[] = {
5799 (char *) "self", NULL
5800 };
5801
5802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
5803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5804 if (SWIG_arg_fail(1)) SWIG_fail;
5805 {
5806 PyThreadState* __tstate = wxPyBeginAllowThreads();
5807 delete arg1;
5808
5809 wxPyEndAllowThreads(__tstate);
5810 if (PyErr_Occurred()) SWIG_fail;
5811 }
5812 Py_INCREF(Py_None); resultobj = Py_None;
5813 return resultobj;
5814 fail:
5815 return NULL;
5816 }
5817
5818
5819 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5820 PyObject *resultobj;
5821 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5822 wxIcon *arg2 = 0 ;
5823 PyObject * obj0 = 0 ;
5824 PyObject * obj1 = 0 ;
5825 char *kwnames[] = {
5826 (char *) "self",(char *) "icon", NULL
5827 };
5828
5829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
5830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5831 if (SWIG_arg_fail(1)) SWIG_fail;
5832 {
5833 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5834 if (SWIG_arg_fail(2)) SWIG_fail;
5835 if (arg2 == NULL) {
5836 SWIG_null_ref("wxIcon");
5837 }
5838 if (SWIG_arg_fail(2)) SWIG_fail;
5839 }
5840 {
5841 PyThreadState* __tstate = wxPyBeginAllowThreads();
5842 (arg1)->AddIcon((wxIcon const &)*arg2);
5843
5844 wxPyEndAllowThreads(__tstate);
5845 if (PyErr_Occurred()) SWIG_fail;
5846 }
5847 Py_INCREF(Py_None); resultobj = Py_None;
5848 return resultobj;
5849 fail:
5850 return NULL;
5851 }
5852
5853
5854 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5855 PyObject *resultobj;
5856 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5857 wxString *arg2 = 0 ;
5858 long arg3 ;
5859 bool temp2 = false ;
5860 PyObject * obj0 = 0 ;
5861 PyObject * obj1 = 0 ;
5862 PyObject * obj2 = 0 ;
5863 char *kwnames[] = {
5864 (char *) "self",(char *) "file",(char *) "type", NULL
5865 };
5866
5867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5869 if (SWIG_arg_fail(1)) SWIG_fail;
5870 {
5871 arg2 = wxString_in_helper(obj1);
5872 if (arg2 == NULL) SWIG_fail;
5873 temp2 = true;
5874 }
5875 {
5876 arg3 = (long)(SWIG_As_long(obj2));
5877 if (SWIG_arg_fail(3)) SWIG_fail;
5878 }
5879 {
5880 PyThreadState* __tstate = wxPyBeginAllowThreads();
5881 (arg1)->AddIcon((wxString const &)*arg2,arg3);
5882
5883 wxPyEndAllowThreads(__tstate);
5884 if (PyErr_Occurred()) SWIG_fail;
5885 }
5886 Py_INCREF(Py_None); resultobj = Py_None;
5887 {
5888 if (temp2)
5889 delete arg2;
5890 }
5891 return resultobj;
5892 fail:
5893 {
5894 if (temp2)
5895 delete arg2;
5896 }
5897 return NULL;
5898 }
5899
5900
5901 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5902 PyObject *resultobj;
5903 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5904 wxSize *arg2 = 0 ;
5905 wxIcon *result;
5906 wxSize temp2 ;
5907 PyObject * obj0 = 0 ;
5908 PyObject * obj1 = 0 ;
5909 char *kwnames[] = {
5910 (char *) "self",(char *) "size", NULL
5911 };
5912
5913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
5914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5915 if (SWIG_arg_fail(1)) SWIG_fail;
5916 {
5917 arg2 = &temp2;
5918 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5919 }
5920 {
5921 PyThreadState* __tstate = wxPyBeginAllowThreads();
5922 {
5923 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
5924 result = (wxIcon *) &_result_ref;
5925 }
5926
5927 wxPyEndAllowThreads(__tstate);
5928 if (PyErr_Occurred()) SWIG_fail;
5929 }
5930 {
5931 wxIcon* resultptr = new wxIcon(*result);
5932 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
5933 }
5934 return resultobj;
5935 fail:
5936 return NULL;
5937 }
5938
5939
5940 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
5941 PyObject *obj;
5942 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5943 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
5944 Py_INCREF(obj);
5945 return Py_BuildValue((char *)"");
5946 }
5947 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5948 PyObject *resultobj;
5949 wxString *arg1 = 0 ;
5950 long arg2 ;
5951 int arg3 = (int) 0 ;
5952 int arg4 = (int) 0 ;
5953 wxCursor *result;
5954 bool temp1 = false ;
5955 PyObject * obj0 = 0 ;
5956 PyObject * obj1 = 0 ;
5957 PyObject * obj2 = 0 ;
5958 PyObject * obj3 = 0 ;
5959 char *kwnames[] = {
5960 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
5961 };
5962
5963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5964 {
5965 arg1 = wxString_in_helper(obj0);
5966 if (arg1 == NULL) SWIG_fail;
5967 temp1 = true;
5968 }
5969 {
5970 arg2 = (long)(SWIG_As_long(obj1));
5971 if (SWIG_arg_fail(2)) SWIG_fail;
5972 }
5973 if (obj2) {
5974 {
5975 arg3 = (int)(SWIG_As_int(obj2));
5976 if (SWIG_arg_fail(3)) SWIG_fail;
5977 }
5978 }
5979 if (obj3) {
5980 {
5981 arg4 = (int)(SWIG_As_int(obj3));
5982 if (SWIG_arg_fail(4)) SWIG_fail;
5983 }
5984 }
5985 {
5986 if (!wxPyCheckForApp()) SWIG_fail;
5987 PyThreadState* __tstate = wxPyBeginAllowThreads();
5988 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
5989
5990 wxPyEndAllowThreads(__tstate);
5991 if (PyErr_Occurred()) SWIG_fail;
5992 }
5993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
5994 {
5995 if (temp1)
5996 delete arg1;
5997 }
5998 return resultobj;
5999 fail:
6000 {
6001 if (temp1)
6002 delete arg1;
6003 }
6004 return NULL;
6005 }
6006
6007
6008 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6009 PyObject *resultobj;
6010 wxCursor *arg1 = (wxCursor *) 0 ;
6011 PyObject * obj0 = 0 ;
6012 char *kwnames[] = {
6013 (char *) "self", NULL
6014 };
6015
6016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
6017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6018 if (SWIG_arg_fail(1)) SWIG_fail;
6019 {
6020 PyThreadState* __tstate = wxPyBeginAllowThreads();
6021 delete arg1;
6022
6023 wxPyEndAllowThreads(__tstate);
6024 if (PyErr_Occurred()) SWIG_fail;
6025 }
6026 Py_INCREF(Py_None); resultobj = Py_None;
6027 return resultobj;
6028 fail:
6029 return NULL;
6030 }
6031
6032
6033 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6034 PyObject *resultobj;
6035 int arg1 ;
6036 wxCursor *result;
6037 PyObject * obj0 = 0 ;
6038 char *kwnames[] = {
6039 (char *) "id", NULL
6040 };
6041
6042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
6043 {
6044 arg1 = (int)(SWIG_As_int(obj0));
6045 if (SWIG_arg_fail(1)) SWIG_fail;
6046 }
6047 {
6048 if (!wxPyCheckForApp()) SWIG_fail;
6049 PyThreadState* __tstate = wxPyBeginAllowThreads();
6050 result = (wxCursor *)new wxCursor(arg1);
6051
6052 wxPyEndAllowThreads(__tstate);
6053 if (PyErr_Occurred()) SWIG_fail;
6054 }
6055 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6056 return resultobj;
6057 fail:
6058 return NULL;
6059 }
6060
6061
6062 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6063 PyObject *resultobj;
6064 wxImage *arg1 = 0 ;
6065 wxCursor *result;
6066 PyObject * obj0 = 0 ;
6067 char *kwnames[] = {
6068 (char *) "image", NULL
6069 };
6070
6071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6072 {
6073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6074 if (SWIG_arg_fail(1)) SWIG_fail;
6075 if (arg1 == NULL) {
6076 SWIG_null_ref("wxImage");
6077 }
6078 if (SWIG_arg_fail(1)) SWIG_fail;
6079 }
6080 {
6081 if (!wxPyCheckForApp()) SWIG_fail;
6082 PyThreadState* __tstate = wxPyBeginAllowThreads();
6083 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6084
6085 wxPyEndAllowThreads(__tstate);
6086 if (PyErr_Occurred()) SWIG_fail;
6087 }
6088 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6089 return resultobj;
6090 fail:
6091 return NULL;
6092 }
6093
6094
6095 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6096 PyObject *resultobj;
6097 wxCursor *arg1 = (wxCursor *) 0 ;
6098 bool result;
6099 PyObject * obj0 = 0 ;
6100 char *kwnames[] = {
6101 (char *) "self", NULL
6102 };
6103
6104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6106 if (SWIG_arg_fail(1)) SWIG_fail;
6107 {
6108 PyThreadState* __tstate = wxPyBeginAllowThreads();
6109 result = (bool)(arg1)->Ok();
6110
6111 wxPyEndAllowThreads(__tstate);
6112 if (PyErr_Occurred()) SWIG_fail;
6113 }
6114 {
6115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6116 }
6117 return resultobj;
6118 fail:
6119 return NULL;
6120 }
6121
6122
6123 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6124 PyObject *obj;
6125 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6126 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6127 Py_INCREF(obj);
6128 return Py_BuildValue((char *)"");
6129 }
6130 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6131 PyObject *resultobj;
6132 int arg1 = (int) 0 ;
6133 int arg2 = (int) 0 ;
6134 int arg3 = (int) 0 ;
6135 int arg4 = (int) 0 ;
6136 wxRegion *result;
6137 PyObject * obj0 = 0 ;
6138 PyObject * obj1 = 0 ;
6139 PyObject * obj2 = 0 ;
6140 PyObject * obj3 = 0 ;
6141 char *kwnames[] = {
6142 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6143 };
6144
6145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6146 if (obj0) {
6147 {
6148 arg1 = (int)(SWIG_As_int(obj0));
6149 if (SWIG_arg_fail(1)) SWIG_fail;
6150 }
6151 }
6152 if (obj1) {
6153 {
6154 arg2 = (int)(SWIG_As_int(obj1));
6155 if (SWIG_arg_fail(2)) SWIG_fail;
6156 }
6157 }
6158 if (obj2) {
6159 {
6160 arg3 = (int)(SWIG_As_int(obj2));
6161 if (SWIG_arg_fail(3)) SWIG_fail;
6162 }
6163 }
6164 if (obj3) {
6165 {
6166 arg4 = (int)(SWIG_As_int(obj3));
6167 if (SWIG_arg_fail(4)) SWIG_fail;
6168 }
6169 }
6170 {
6171 if (!wxPyCheckForApp()) SWIG_fail;
6172 PyThreadState* __tstate = wxPyBeginAllowThreads();
6173 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6174
6175 wxPyEndAllowThreads(__tstate);
6176 if (PyErr_Occurred()) SWIG_fail;
6177 }
6178 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6179 return resultobj;
6180 fail:
6181 return NULL;
6182 }
6183
6184
6185 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6186 PyObject *resultobj;
6187 wxBitmap *arg1 = 0 ;
6188 wxRegion *result;
6189 PyObject * obj0 = 0 ;
6190 char *kwnames[] = {
6191 (char *) "bmp", NULL
6192 };
6193
6194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6195 {
6196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6197 if (SWIG_arg_fail(1)) SWIG_fail;
6198 if (arg1 == NULL) {
6199 SWIG_null_ref("wxBitmap");
6200 }
6201 if (SWIG_arg_fail(1)) SWIG_fail;
6202 }
6203 {
6204 if (!wxPyCheckForApp()) SWIG_fail;
6205 PyThreadState* __tstate = wxPyBeginAllowThreads();
6206 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6207
6208 wxPyEndAllowThreads(__tstate);
6209 if (PyErr_Occurred()) SWIG_fail;
6210 }
6211 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6212 return resultobj;
6213 fail:
6214 return NULL;
6215 }
6216
6217
6218 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6219 PyObject *resultobj;
6220 wxBitmap *arg1 = 0 ;
6221 wxColour *arg2 = 0 ;
6222 int arg3 = (int) 0 ;
6223 wxRegion *result;
6224 wxColour temp2 ;
6225 PyObject * obj0 = 0 ;
6226 PyObject * obj1 = 0 ;
6227 PyObject * obj2 = 0 ;
6228 char *kwnames[] = {
6229 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6230 };
6231
6232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6233 {
6234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6235 if (SWIG_arg_fail(1)) SWIG_fail;
6236 if (arg1 == NULL) {
6237 SWIG_null_ref("wxBitmap");
6238 }
6239 if (SWIG_arg_fail(1)) SWIG_fail;
6240 }
6241 {
6242 arg2 = &temp2;
6243 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6244 }
6245 if (obj2) {
6246 {
6247 arg3 = (int)(SWIG_As_int(obj2));
6248 if (SWIG_arg_fail(3)) SWIG_fail;
6249 }
6250 }
6251 {
6252 if (!wxPyCheckForApp()) SWIG_fail;
6253 PyThreadState* __tstate = wxPyBeginAllowThreads();
6254 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6255
6256 wxPyEndAllowThreads(__tstate);
6257 if (PyErr_Occurred()) SWIG_fail;
6258 }
6259 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6260 return resultobj;
6261 fail:
6262 return NULL;
6263 }
6264
6265
6266 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6267 PyObject *resultobj;
6268 int arg1 ;
6269 wxPoint *arg2 = (wxPoint *) 0 ;
6270 int arg3 = (int) wxWINDING_RULE ;
6271 wxRegion *result;
6272 PyObject * obj0 = 0 ;
6273 PyObject * obj1 = 0 ;
6274 char *kwnames[] = {
6275 (char *) "points",(char *) "fillStyle", NULL
6276 };
6277
6278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6279 {
6280 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6281 if (arg2 == NULL) SWIG_fail;
6282 }
6283 if (obj1) {
6284 {
6285 arg3 = (int)(SWIG_As_int(obj1));
6286 if (SWIG_arg_fail(3)) SWIG_fail;
6287 }
6288 }
6289 {
6290 if (!wxPyCheckForApp()) SWIG_fail;
6291 PyThreadState* __tstate = wxPyBeginAllowThreads();
6292 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6293
6294 wxPyEndAllowThreads(__tstate);
6295 if (PyErr_Occurred()) SWIG_fail;
6296 }
6297 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6298 {
6299 if (arg2) delete [] arg2;
6300 }
6301 return resultobj;
6302 fail:
6303 {
6304 if (arg2) delete [] arg2;
6305 }
6306 return NULL;
6307 }
6308
6309
6310 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6311 PyObject *resultobj;
6312 wxRegion *arg1 = (wxRegion *) 0 ;
6313 PyObject * obj0 = 0 ;
6314 char *kwnames[] = {
6315 (char *) "self", NULL
6316 };
6317
6318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6320 if (SWIG_arg_fail(1)) SWIG_fail;
6321 {
6322 PyThreadState* __tstate = wxPyBeginAllowThreads();
6323 delete arg1;
6324
6325 wxPyEndAllowThreads(__tstate);
6326 if (PyErr_Occurred()) SWIG_fail;
6327 }
6328 Py_INCREF(Py_None); resultobj = Py_None;
6329 return resultobj;
6330 fail:
6331 return NULL;
6332 }
6333
6334
6335 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6336 PyObject *resultobj;
6337 wxRegion *arg1 = (wxRegion *) 0 ;
6338 PyObject * obj0 = 0 ;
6339 char *kwnames[] = {
6340 (char *) "self", NULL
6341 };
6342
6343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6345 if (SWIG_arg_fail(1)) SWIG_fail;
6346 {
6347 PyThreadState* __tstate = wxPyBeginAllowThreads();
6348 (arg1)->Clear();
6349
6350 wxPyEndAllowThreads(__tstate);
6351 if (PyErr_Occurred()) SWIG_fail;
6352 }
6353 Py_INCREF(Py_None); resultobj = Py_None;
6354 return resultobj;
6355 fail:
6356 return NULL;
6357 }
6358
6359
6360 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6361 PyObject *resultobj;
6362 wxRegion *arg1 = (wxRegion *) 0 ;
6363 int arg2 ;
6364 int arg3 ;
6365 bool result;
6366 PyObject * obj0 = 0 ;
6367 PyObject * obj1 = 0 ;
6368 PyObject * obj2 = 0 ;
6369 char *kwnames[] = {
6370 (char *) "self",(char *) "x",(char *) "y", NULL
6371 };
6372
6373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6375 if (SWIG_arg_fail(1)) SWIG_fail;
6376 {
6377 arg2 = (int)(SWIG_As_int(obj1));
6378 if (SWIG_arg_fail(2)) SWIG_fail;
6379 }
6380 {
6381 arg3 = (int)(SWIG_As_int(obj2));
6382 if (SWIG_arg_fail(3)) SWIG_fail;
6383 }
6384 {
6385 PyThreadState* __tstate = wxPyBeginAllowThreads();
6386 result = (bool)(arg1)->Offset(arg2,arg3);
6387
6388 wxPyEndAllowThreads(__tstate);
6389 if (PyErr_Occurred()) SWIG_fail;
6390 }
6391 {
6392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6393 }
6394 return resultobj;
6395 fail:
6396 return NULL;
6397 }
6398
6399
6400 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6401 PyObject *resultobj;
6402 wxRegion *arg1 = (wxRegion *) 0 ;
6403 int arg2 ;
6404 int arg3 ;
6405 wxRegionContain result;
6406 PyObject * obj0 = 0 ;
6407 PyObject * obj1 = 0 ;
6408 PyObject * obj2 = 0 ;
6409 char *kwnames[] = {
6410 (char *) "self",(char *) "x",(char *) "y", NULL
6411 };
6412
6413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6415 if (SWIG_arg_fail(1)) SWIG_fail;
6416 {
6417 arg2 = (int)(SWIG_As_int(obj1));
6418 if (SWIG_arg_fail(2)) SWIG_fail;
6419 }
6420 {
6421 arg3 = (int)(SWIG_As_int(obj2));
6422 if (SWIG_arg_fail(3)) SWIG_fail;
6423 }
6424 {
6425 PyThreadState* __tstate = wxPyBeginAllowThreads();
6426 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6427
6428 wxPyEndAllowThreads(__tstate);
6429 if (PyErr_Occurred()) SWIG_fail;
6430 }
6431 resultobj = SWIG_From_int((result));
6432 return resultobj;
6433 fail:
6434 return NULL;
6435 }
6436
6437
6438 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6439 PyObject *resultobj;
6440 wxRegion *arg1 = (wxRegion *) 0 ;
6441 wxPoint *arg2 = 0 ;
6442 wxRegionContain result;
6443 wxPoint temp2 ;
6444 PyObject * obj0 = 0 ;
6445 PyObject * obj1 = 0 ;
6446 char *kwnames[] = {
6447 (char *) "self",(char *) "pt", NULL
6448 };
6449
6450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6452 if (SWIG_arg_fail(1)) SWIG_fail;
6453 {
6454 arg2 = &temp2;
6455 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6456 }
6457 {
6458 PyThreadState* __tstate = wxPyBeginAllowThreads();
6459 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
6460
6461 wxPyEndAllowThreads(__tstate);
6462 if (PyErr_Occurred()) SWIG_fail;
6463 }
6464 resultobj = SWIG_From_int((result));
6465 return resultobj;
6466 fail:
6467 return NULL;
6468 }
6469
6470
6471 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
6472 PyObject *resultobj;
6473 wxRegion *arg1 = (wxRegion *) 0 ;
6474 wxRect *arg2 = 0 ;
6475 wxRegionContain result;
6476 wxRect temp2 ;
6477 PyObject * obj0 = 0 ;
6478 PyObject * obj1 = 0 ;
6479 char *kwnames[] = {
6480 (char *) "self",(char *) "rect", NULL
6481 };
6482
6483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
6484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6485 if (SWIG_arg_fail(1)) SWIG_fail;
6486 {
6487 arg2 = &temp2;
6488 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6489 }
6490 {
6491 PyThreadState* __tstate = wxPyBeginAllowThreads();
6492 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
6493
6494 wxPyEndAllowThreads(__tstate);
6495 if (PyErr_Occurred()) SWIG_fail;
6496 }
6497 resultobj = SWIG_From_int((result));
6498 return resultobj;
6499 fail:
6500 return NULL;
6501 }
6502
6503
6504 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
6505 PyObject *resultobj;
6506 wxRegion *arg1 = (wxRegion *) 0 ;
6507 int arg2 ;
6508 int arg3 ;
6509 int arg4 ;
6510 int arg5 ;
6511 wxRegionContain result;
6512 PyObject * obj0 = 0 ;
6513 PyObject * obj1 = 0 ;
6514 PyObject * obj2 = 0 ;
6515 PyObject * obj3 = 0 ;
6516 PyObject * obj4 = 0 ;
6517 char *kwnames[] = {
6518 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
6519 };
6520
6521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6523 if (SWIG_arg_fail(1)) SWIG_fail;
6524 {
6525 arg2 = (int)(SWIG_As_int(obj1));
6526 if (SWIG_arg_fail(2)) SWIG_fail;
6527 }
6528 {
6529 arg3 = (int)(SWIG_As_int(obj2));
6530 if (SWIG_arg_fail(3)) SWIG_fail;
6531 }
6532 {
6533 arg4 = (int)(SWIG_As_int(obj3));
6534 if (SWIG_arg_fail(4)) SWIG_fail;
6535 }
6536 {
6537 arg5 = (int)(SWIG_As_int(obj4));
6538 if (SWIG_arg_fail(5)) SWIG_fail;
6539 }
6540 {
6541 PyThreadState* __tstate = wxPyBeginAllowThreads();
6542 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
6543
6544 wxPyEndAllowThreads(__tstate);
6545 if (PyErr_Occurred()) SWIG_fail;
6546 }
6547 resultobj = SWIG_From_int((result));
6548 return resultobj;
6549 fail:
6550 return NULL;
6551 }
6552
6553
6554 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
6555 PyObject *resultobj;
6556 wxRegion *arg1 = (wxRegion *) 0 ;
6557 wxRect result;
6558 PyObject * obj0 = 0 ;
6559 char *kwnames[] = {
6560 (char *) "self", NULL
6561 };
6562
6563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
6564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6565 if (SWIG_arg_fail(1)) SWIG_fail;
6566 {
6567 PyThreadState* __tstate = wxPyBeginAllowThreads();
6568 result = (arg1)->GetBox();
6569
6570 wxPyEndAllowThreads(__tstate);
6571 if (PyErr_Occurred()) SWIG_fail;
6572 }
6573 {
6574 wxRect * resultptr;
6575 resultptr = new wxRect((wxRect &)(result));
6576 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6577 }
6578 return resultobj;
6579 fail:
6580 return NULL;
6581 }
6582
6583
6584 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
6585 PyObject *resultobj;
6586 wxRegion *arg1 = (wxRegion *) 0 ;
6587 int arg2 ;
6588 int arg3 ;
6589 int arg4 ;
6590 int arg5 ;
6591 bool result;
6592 PyObject * obj0 = 0 ;
6593 PyObject * obj1 = 0 ;
6594 PyObject * obj2 = 0 ;
6595 PyObject * obj3 = 0 ;
6596 PyObject * obj4 = 0 ;
6597 char *kwnames[] = {
6598 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6599 };
6600
6601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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 = (int)(SWIG_As_int(obj1));
6606 if (SWIG_arg_fail(2)) SWIG_fail;
6607 }
6608 {
6609 arg3 = (int)(SWIG_As_int(obj2));
6610 if (SWIG_arg_fail(3)) SWIG_fail;
6611 }
6612 {
6613 arg4 = (int)(SWIG_As_int(obj3));
6614 if (SWIG_arg_fail(4)) SWIG_fail;
6615 }
6616 {
6617 arg5 = (int)(SWIG_As_int(obj4));
6618 if (SWIG_arg_fail(5)) SWIG_fail;
6619 }
6620 {
6621 PyThreadState* __tstate = wxPyBeginAllowThreads();
6622 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
6623
6624 wxPyEndAllowThreads(__tstate);
6625 if (PyErr_Occurred()) SWIG_fail;
6626 }
6627 {
6628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6629 }
6630 return resultobj;
6631 fail:
6632 return NULL;
6633 }
6634
6635
6636 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6637 PyObject *resultobj;
6638 wxRegion *arg1 = (wxRegion *) 0 ;
6639 wxRect *arg2 = 0 ;
6640 bool result;
6641 wxRect temp2 ;
6642 PyObject * obj0 = 0 ;
6643 PyObject * obj1 = 0 ;
6644 char *kwnames[] = {
6645 (char *) "self",(char *) "rect", NULL
6646 };
6647
6648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6650 if (SWIG_arg_fail(1)) SWIG_fail;
6651 {
6652 arg2 = &temp2;
6653 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6654 }
6655 {
6656 PyThreadState* __tstate = wxPyBeginAllowThreads();
6657 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
6658
6659 wxPyEndAllowThreads(__tstate);
6660 if (PyErr_Occurred()) SWIG_fail;
6661 }
6662 {
6663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6664 }
6665 return resultobj;
6666 fail:
6667 return NULL;
6668 }
6669
6670
6671 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6672 PyObject *resultobj;
6673 wxRegion *arg1 = (wxRegion *) 0 ;
6674 wxRegion *arg2 = 0 ;
6675 bool result;
6676 PyObject * obj0 = 0 ;
6677 PyObject * obj1 = 0 ;
6678 char *kwnames[] = {
6679 (char *) "self",(char *) "region", NULL
6680 };
6681
6682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
6683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6684 if (SWIG_arg_fail(1)) SWIG_fail;
6685 {
6686 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6687 if (SWIG_arg_fail(2)) SWIG_fail;
6688 if (arg2 == NULL) {
6689 SWIG_null_ref("wxRegion");
6690 }
6691 if (SWIG_arg_fail(2)) SWIG_fail;
6692 }
6693 {
6694 PyThreadState* __tstate = wxPyBeginAllowThreads();
6695 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
6696
6697 wxPyEndAllowThreads(__tstate);
6698 if (PyErr_Occurred()) SWIG_fail;
6699 }
6700 {
6701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6702 }
6703 return resultobj;
6704 fail:
6705 return NULL;
6706 }
6707
6708
6709 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
6710 PyObject *resultobj;
6711 wxRegion *arg1 = (wxRegion *) 0 ;
6712 bool result;
6713 PyObject * obj0 = 0 ;
6714 char *kwnames[] = {
6715 (char *) "self", NULL
6716 };
6717
6718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
6719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6720 if (SWIG_arg_fail(1)) SWIG_fail;
6721 {
6722 PyThreadState* __tstate = wxPyBeginAllowThreads();
6723 result = (bool)(arg1)->IsEmpty();
6724
6725 wxPyEndAllowThreads(__tstate);
6726 if (PyErr_Occurred()) SWIG_fail;
6727 }
6728 {
6729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6730 }
6731 return resultobj;
6732 fail:
6733 return NULL;
6734 }
6735
6736
6737 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6738 PyObject *resultobj;
6739 wxRegion *arg1 = (wxRegion *) 0 ;
6740 int arg2 ;
6741 int arg3 ;
6742 int arg4 ;
6743 int arg5 ;
6744 bool result;
6745 PyObject * obj0 = 0 ;
6746 PyObject * obj1 = 0 ;
6747 PyObject * obj2 = 0 ;
6748 PyObject * obj3 = 0 ;
6749 PyObject * obj4 = 0 ;
6750 char *kwnames[] = {
6751 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6752 };
6753
6754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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 = (int)(SWIG_As_int(obj1));
6759 if (SWIG_arg_fail(2)) SWIG_fail;
6760 }
6761 {
6762 arg3 = (int)(SWIG_As_int(obj2));
6763 if (SWIG_arg_fail(3)) SWIG_fail;
6764 }
6765 {
6766 arg4 = (int)(SWIG_As_int(obj3));
6767 if (SWIG_arg_fail(4)) SWIG_fail;
6768 }
6769 {
6770 arg5 = (int)(SWIG_As_int(obj4));
6771 if (SWIG_arg_fail(5)) SWIG_fail;
6772 }
6773 {
6774 PyThreadState* __tstate = wxPyBeginAllowThreads();
6775 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
6776
6777 wxPyEndAllowThreads(__tstate);
6778 if (PyErr_Occurred()) SWIG_fail;
6779 }
6780 {
6781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6782 }
6783 return resultobj;
6784 fail:
6785 return NULL;
6786 }
6787
6788
6789 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
6790 PyObject *resultobj;
6791 wxRegion *arg1 = (wxRegion *) 0 ;
6792 wxRect *arg2 = 0 ;
6793 bool result;
6794 wxRect temp2 ;
6795 PyObject * obj0 = 0 ;
6796 PyObject * obj1 = 0 ;
6797 char *kwnames[] = {
6798 (char *) "self",(char *) "rect", NULL
6799 };
6800
6801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
6802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6803 if (SWIG_arg_fail(1)) SWIG_fail;
6804 {
6805 arg2 = &temp2;
6806 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6807 }
6808 {
6809 PyThreadState* __tstate = wxPyBeginAllowThreads();
6810 result = (bool)(arg1)->Union((wxRect const &)*arg2);
6811
6812 wxPyEndAllowThreads(__tstate);
6813 if (PyErr_Occurred()) SWIG_fail;
6814 }
6815 {
6816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6817 }
6818 return resultobj;
6819 fail:
6820 return NULL;
6821 }
6822
6823
6824 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6825 PyObject *resultobj;
6826 wxRegion *arg1 = (wxRegion *) 0 ;
6827 wxRegion *arg2 = 0 ;
6828 bool result;
6829 PyObject * obj0 = 0 ;
6830 PyObject * obj1 = 0 ;
6831 char *kwnames[] = {
6832 (char *) "self",(char *) "region", NULL
6833 };
6834
6835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
6836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6837 if (SWIG_arg_fail(1)) SWIG_fail;
6838 {
6839 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6840 if (SWIG_arg_fail(2)) SWIG_fail;
6841 if (arg2 == NULL) {
6842 SWIG_null_ref("wxRegion");
6843 }
6844 if (SWIG_arg_fail(2)) SWIG_fail;
6845 }
6846 {
6847 PyThreadState* __tstate = wxPyBeginAllowThreads();
6848 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
6849
6850 wxPyEndAllowThreads(__tstate);
6851 if (PyErr_Occurred()) SWIG_fail;
6852 }
6853 {
6854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6855 }
6856 return resultobj;
6857 fail:
6858 return NULL;
6859 }
6860
6861
6862 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
6863 PyObject *resultobj;
6864 wxRegion *arg1 = (wxRegion *) 0 ;
6865 int arg2 ;
6866 int arg3 ;
6867 int arg4 ;
6868 int arg5 ;
6869 bool result;
6870 PyObject * obj0 = 0 ;
6871 PyObject * obj1 = 0 ;
6872 PyObject * obj2 = 0 ;
6873 PyObject * obj3 = 0 ;
6874 PyObject * obj4 = 0 ;
6875 char *kwnames[] = {
6876 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6877 };
6878
6879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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 = (int)(SWIG_As_int(obj1));
6884 if (SWIG_arg_fail(2)) SWIG_fail;
6885 }
6886 {
6887 arg3 = (int)(SWIG_As_int(obj2));
6888 if (SWIG_arg_fail(3)) SWIG_fail;
6889 }
6890 {
6891 arg4 = (int)(SWIG_As_int(obj3));
6892 if (SWIG_arg_fail(4)) SWIG_fail;
6893 }
6894 {
6895 arg5 = (int)(SWIG_As_int(obj4));
6896 if (SWIG_arg_fail(5)) SWIG_fail;
6897 }
6898 {
6899 PyThreadState* __tstate = wxPyBeginAllowThreads();
6900 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
6901
6902 wxPyEndAllowThreads(__tstate);
6903 if (PyErr_Occurred()) SWIG_fail;
6904 }
6905 {
6906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6907 }
6908 return resultobj;
6909 fail:
6910 return NULL;
6911 }
6912
6913
6914 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
6915 PyObject *resultobj;
6916 wxRegion *arg1 = (wxRegion *) 0 ;
6917 wxRect *arg2 = 0 ;
6918 bool result;
6919 wxRect temp2 ;
6920 PyObject * obj0 = 0 ;
6921 PyObject * obj1 = 0 ;
6922 char *kwnames[] = {
6923 (char *) "self",(char *) "rect", NULL
6924 };
6925
6926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
6927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6928 if (SWIG_arg_fail(1)) SWIG_fail;
6929 {
6930 arg2 = &temp2;
6931 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6932 }
6933 {
6934 PyThreadState* __tstate = wxPyBeginAllowThreads();
6935 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
6936
6937 wxPyEndAllowThreads(__tstate);
6938 if (PyErr_Occurred()) SWIG_fail;
6939 }
6940 {
6941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6942 }
6943 return resultobj;
6944 fail:
6945 return NULL;
6946 }
6947
6948
6949 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6950 PyObject *resultobj;
6951 wxRegion *arg1 = (wxRegion *) 0 ;
6952 wxRegion *arg2 = 0 ;
6953 bool result;
6954 PyObject * obj0 = 0 ;
6955 PyObject * obj1 = 0 ;
6956 char *kwnames[] = {
6957 (char *) "self",(char *) "region", NULL
6958 };
6959
6960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
6961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6962 if (SWIG_arg_fail(1)) SWIG_fail;
6963 {
6964 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6965 if (SWIG_arg_fail(2)) SWIG_fail;
6966 if (arg2 == NULL) {
6967 SWIG_null_ref("wxRegion");
6968 }
6969 if (SWIG_arg_fail(2)) SWIG_fail;
6970 }
6971 {
6972 PyThreadState* __tstate = wxPyBeginAllowThreads();
6973 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
6974
6975 wxPyEndAllowThreads(__tstate);
6976 if (PyErr_Occurred()) SWIG_fail;
6977 }
6978 {
6979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6980 }
6981 return resultobj;
6982 fail:
6983 return NULL;
6984 }
6985
6986
6987 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
6988 PyObject *resultobj;
6989 wxRegion *arg1 = (wxRegion *) 0 ;
6990 int arg2 ;
6991 int arg3 ;
6992 int arg4 ;
6993 int arg5 ;
6994 bool result;
6995 PyObject * obj0 = 0 ;
6996 PyObject * obj1 = 0 ;
6997 PyObject * obj2 = 0 ;
6998 PyObject * obj3 = 0 ;
6999 PyObject * obj4 = 0 ;
7000 char *kwnames[] = {
7001 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7002 };
7003
7004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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 = (int)(SWIG_As_int(obj1));
7009 if (SWIG_arg_fail(2)) SWIG_fail;
7010 }
7011 {
7012 arg3 = (int)(SWIG_As_int(obj2));
7013 if (SWIG_arg_fail(3)) SWIG_fail;
7014 }
7015 {
7016 arg4 = (int)(SWIG_As_int(obj3));
7017 if (SWIG_arg_fail(4)) SWIG_fail;
7018 }
7019 {
7020 arg5 = (int)(SWIG_As_int(obj4));
7021 if (SWIG_arg_fail(5)) SWIG_fail;
7022 }
7023 {
7024 PyThreadState* __tstate = wxPyBeginAllowThreads();
7025 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
7026
7027 wxPyEndAllowThreads(__tstate);
7028 if (PyErr_Occurred()) SWIG_fail;
7029 }
7030 {
7031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7032 }
7033 return resultobj;
7034 fail:
7035 return NULL;
7036 }
7037
7038
7039 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
7040 PyObject *resultobj;
7041 wxRegion *arg1 = (wxRegion *) 0 ;
7042 wxRect *arg2 = 0 ;
7043 bool result;
7044 wxRect temp2 ;
7045 PyObject * obj0 = 0 ;
7046 PyObject * obj1 = 0 ;
7047 char *kwnames[] = {
7048 (char *) "self",(char *) "rect", NULL
7049 };
7050
7051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7053 if (SWIG_arg_fail(1)) SWIG_fail;
7054 {
7055 arg2 = &temp2;
7056 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7057 }
7058 {
7059 PyThreadState* __tstate = wxPyBeginAllowThreads();
7060 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7061
7062 wxPyEndAllowThreads(__tstate);
7063 if (PyErr_Occurred()) SWIG_fail;
7064 }
7065 {
7066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7067 }
7068 return resultobj;
7069 fail:
7070 return NULL;
7071 }
7072
7073
7074 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7075 PyObject *resultobj;
7076 wxRegion *arg1 = (wxRegion *) 0 ;
7077 wxRegion *arg2 = 0 ;
7078 bool result;
7079 PyObject * obj0 = 0 ;
7080 PyObject * obj1 = 0 ;
7081 char *kwnames[] = {
7082 (char *) "self",(char *) "region", NULL
7083 };
7084
7085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7087 if (SWIG_arg_fail(1)) SWIG_fail;
7088 {
7089 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7090 if (SWIG_arg_fail(2)) SWIG_fail;
7091 if (arg2 == NULL) {
7092 SWIG_null_ref("wxRegion");
7093 }
7094 if (SWIG_arg_fail(2)) SWIG_fail;
7095 }
7096 {
7097 PyThreadState* __tstate = wxPyBeginAllowThreads();
7098 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7099
7100 wxPyEndAllowThreads(__tstate);
7101 if (PyErr_Occurred()) SWIG_fail;
7102 }
7103 {
7104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7105 }
7106 return resultobj;
7107 fail:
7108 return NULL;
7109 }
7110
7111
7112 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7113 PyObject *resultobj;
7114 wxRegion *arg1 = (wxRegion *) 0 ;
7115 SwigValueWrapper<wxBitmap > result;
7116 PyObject * obj0 = 0 ;
7117 char *kwnames[] = {
7118 (char *) "self", NULL
7119 };
7120
7121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7123 if (SWIG_arg_fail(1)) SWIG_fail;
7124 {
7125 PyThreadState* __tstate = wxPyBeginAllowThreads();
7126 result = (arg1)->ConvertToBitmap();
7127
7128 wxPyEndAllowThreads(__tstate);
7129 if (PyErr_Occurred()) SWIG_fail;
7130 }
7131 {
7132 wxBitmap * resultptr;
7133 resultptr = new wxBitmap((wxBitmap &)(result));
7134 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7135 }
7136 return resultobj;
7137 fail:
7138 return NULL;
7139 }
7140
7141
7142 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7143 PyObject *resultobj;
7144 wxRegion *arg1 = (wxRegion *) 0 ;
7145 wxBitmap *arg2 = 0 ;
7146 bool result;
7147 PyObject * obj0 = 0 ;
7148 PyObject * obj1 = 0 ;
7149 char *kwnames[] = {
7150 (char *) "self",(char *) "bmp", NULL
7151 };
7152
7153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7155 if (SWIG_arg_fail(1)) SWIG_fail;
7156 {
7157 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7158 if (SWIG_arg_fail(2)) SWIG_fail;
7159 if (arg2 == NULL) {
7160 SWIG_null_ref("wxBitmap");
7161 }
7162 if (SWIG_arg_fail(2)) SWIG_fail;
7163 }
7164 {
7165 PyThreadState* __tstate = wxPyBeginAllowThreads();
7166 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7167
7168 wxPyEndAllowThreads(__tstate);
7169 if (PyErr_Occurred()) SWIG_fail;
7170 }
7171 {
7172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7173 }
7174 return resultobj;
7175 fail:
7176 return NULL;
7177 }
7178
7179
7180 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7181 PyObject *resultobj;
7182 wxRegion *arg1 = (wxRegion *) 0 ;
7183 wxBitmap *arg2 = 0 ;
7184 wxColour *arg3 = 0 ;
7185 int arg4 = (int) 0 ;
7186 bool result;
7187 wxColour temp3 ;
7188 PyObject * obj0 = 0 ;
7189 PyObject * obj1 = 0 ;
7190 PyObject * obj2 = 0 ;
7191 PyObject * obj3 = 0 ;
7192 char *kwnames[] = {
7193 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7194 };
7195
7196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7198 if (SWIG_arg_fail(1)) SWIG_fail;
7199 {
7200 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7201 if (SWIG_arg_fail(2)) SWIG_fail;
7202 if (arg2 == NULL) {
7203 SWIG_null_ref("wxBitmap");
7204 }
7205 if (SWIG_arg_fail(2)) SWIG_fail;
7206 }
7207 {
7208 arg3 = &temp3;
7209 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7210 }
7211 if (obj3) {
7212 {
7213 arg4 = (int)(SWIG_As_int(obj3));
7214 if (SWIG_arg_fail(4)) SWIG_fail;
7215 }
7216 }
7217 {
7218 PyThreadState* __tstate = wxPyBeginAllowThreads();
7219 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7220
7221 wxPyEndAllowThreads(__tstate);
7222 if (PyErr_Occurred()) SWIG_fail;
7223 }
7224 {
7225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7226 }
7227 return resultobj;
7228 fail:
7229 return NULL;
7230 }
7231
7232
7233 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7234 PyObject *obj;
7235 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7236 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7237 Py_INCREF(obj);
7238 return Py_BuildValue((char *)"");
7239 }
7240 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7241 PyObject *resultobj;
7242 wxRegion *arg1 = 0 ;
7243 wxRegionIterator *result;
7244 PyObject * obj0 = 0 ;
7245 char *kwnames[] = {
7246 (char *) "region", NULL
7247 };
7248
7249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7250 {
7251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7252 if (SWIG_arg_fail(1)) SWIG_fail;
7253 if (arg1 == NULL) {
7254 SWIG_null_ref("wxRegion");
7255 }
7256 if (SWIG_arg_fail(1)) SWIG_fail;
7257 }
7258 {
7259 if (!wxPyCheckForApp()) SWIG_fail;
7260 PyThreadState* __tstate = wxPyBeginAllowThreads();
7261 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7262
7263 wxPyEndAllowThreads(__tstate);
7264 if (PyErr_Occurred()) SWIG_fail;
7265 }
7266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7267 return resultobj;
7268 fail:
7269 return NULL;
7270 }
7271
7272
7273 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7274 PyObject *resultobj;
7275 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7276 PyObject * obj0 = 0 ;
7277 char *kwnames[] = {
7278 (char *) "self", NULL
7279 };
7280
7281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7283 if (SWIG_arg_fail(1)) SWIG_fail;
7284 {
7285 PyThreadState* __tstate = wxPyBeginAllowThreads();
7286 delete arg1;
7287
7288 wxPyEndAllowThreads(__tstate);
7289 if (PyErr_Occurred()) SWIG_fail;
7290 }
7291 Py_INCREF(Py_None); resultobj = Py_None;
7292 return resultobj;
7293 fail:
7294 return NULL;
7295 }
7296
7297
7298 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7299 PyObject *resultobj;
7300 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7301 int result;
7302 PyObject * obj0 = 0 ;
7303 char *kwnames[] = {
7304 (char *) "self", NULL
7305 };
7306
7307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7309 if (SWIG_arg_fail(1)) SWIG_fail;
7310 {
7311 PyThreadState* __tstate = wxPyBeginAllowThreads();
7312 result = (int)(arg1)->GetX();
7313
7314 wxPyEndAllowThreads(__tstate);
7315 if (PyErr_Occurred()) SWIG_fail;
7316 }
7317 {
7318 resultobj = SWIG_From_int((int)(result));
7319 }
7320 return resultobj;
7321 fail:
7322 return NULL;
7323 }
7324
7325
7326 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7327 PyObject *resultobj;
7328 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7329 int result;
7330 PyObject * obj0 = 0 ;
7331 char *kwnames[] = {
7332 (char *) "self", NULL
7333 };
7334
7335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7337 if (SWIG_arg_fail(1)) SWIG_fail;
7338 {
7339 PyThreadState* __tstate = wxPyBeginAllowThreads();
7340 result = (int)(arg1)->GetY();
7341
7342 wxPyEndAllowThreads(__tstate);
7343 if (PyErr_Occurred()) SWIG_fail;
7344 }
7345 {
7346 resultobj = SWIG_From_int((int)(result));
7347 }
7348 return resultobj;
7349 fail:
7350 return NULL;
7351 }
7352
7353
7354 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7355 PyObject *resultobj;
7356 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7357 int result;
7358 PyObject * obj0 = 0 ;
7359 char *kwnames[] = {
7360 (char *) "self", NULL
7361 };
7362
7363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7365 if (SWIG_arg_fail(1)) SWIG_fail;
7366 {
7367 PyThreadState* __tstate = wxPyBeginAllowThreads();
7368 result = (int)(arg1)->GetW();
7369
7370 wxPyEndAllowThreads(__tstate);
7371 if (PyErr_Occurred()) SWIG_fail;
7372 }
7373 {
7374 resultobj = SWIG_From_int((int)(result));
7375 }
7376 return resultobj;
7377 fail:
7378 return NULL;
7379 }
7380
7381
7382 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7383 PyObject *resultobj;
7384 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7385 int result;
7386 PyObject * obj0 = 0 ;
7387 char *kwnames[] = {
7388 (char *) "self", NULL
7389 };
7390
7391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7393 if (SWIG_arg_fail(1)) SWIG_fail;
7394 {
7395 PyThreadState* __tstate = wxPyBeginAllowThreads();
7396 result = (int)(arg1)->GetWidth();
7397
7398 wxPyEndAllowThreads(__tstate);
7399 if (PyErr_Occurred()) SWIG_fail;
7400 }
7401 {
7402 resultobj = SWIG_From_int((int)(result));
7403 }
7404 return resultobj;
7405 fail:
7406 return NULL;
7407 }
7408
7409
7410 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7411 PyObject *resultobj;
7412 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7413 int result;
7414 PyObject * obj0 = 0 ;
7415 char *kwnames[] = {
7416 (char *) "self", NULL
7417 };
7418
7419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7421 if (SWIG_arg_fail(1)) SWIG_fail;
7422 {
7423 PyThreadState* __tstate = wxPyBeginAllowThreads();
7424 result = (int)(arg1)->GetH();
7425
7426 wxPyEndAllowThreads(__tstate);
7427 if (PyErr_Occurred()) SWIG_fail;
7428 }
7429 {
7430 resultobj = SWIG_From_int((int)(result));
7431 }
7432 return resultobj;
7433 fail:
7434 return NULL;
7435 }
7436
7437
7438 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7439 PyObject *resultobj;
7440 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7441 int result;
7442 PyObject * obj0 = 0 ;
7443 char *kwnames[] = {
7444 (char *) "self", NULL
7445 };
7446
7447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7449 if (SWIG_arg_fail(1)) SWIG_fail;
7450 {
7451 PyThreadState* __tstate = wxPyBeginAllowThreads();
7452 result = (int)(arg1)->GetHeight();
7453
7454 wxPyEndAllowThreads(__tstate);
7455 if (PyErr_Occurred()) SWIG_fail;
7456 }
7457 {
7458 resultobj = SWIG_From_int((int)(result));
7459 }
7460 return resultobj;
7461 fail:
7462 return NULL;
7463 }
7464
7465
7466 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
7467 PyObject *resultobj;
7468 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7469 wxRect result;
7470 PyObject * obj0 = 0 ;
7471 char *kwnames[] = {
7472 (char *) "self", NULL
7473 };
7474
7475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
7476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7477 if (SWIG_arg_fail(1)) SWIG_fail;
7478 {
7479 PyThreadState* __tstate = wxPyBeginAllowThreads();
7480 result = (arg1)->GetRect();
7481
7482 wxPyEndAllowThreads(__tstate);
7483 if (PyErr_Occurred()) SWIG_fail;
7484 }
7485 {
7486 wxRect * resultptr;
7487 resultptr = new wxRect((wxRect &)(result));
7488 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7489 }
7490 return resultobj;
7491 fail:
7492 return NULL;
7493 }
7494
7495
7496 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
7497 PyObject *resultobj;
7498 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7499 bool result;
7500 PyObject * obj0 = 0 ;
7501 char *kwnames[] = {
7502 (char *) "self", NULL
7503 };
7504
7505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
7506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7507 if (SWIG_arg_fail(1)) SWIG_fail;
7508 {
7509 PyThreadState* __tstate = wxPyBeginAllowThreads();
7510 result = (bool)(arg1)->HaveRects();
7511
7512 wxPyEndAllowThreads(__tstate);
7513 if (PyErr_Occurred()) SWIG_fail;
7514 }
7515 {
7516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7517 }
7518 return resultobj;
7519 fail:
7520 return NULL;
7521 }
7522
7523
7524 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
7525 PyObject *resultobj;
7526 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7527 PyObject * obj0 = 0 ;
7528 char *kwnames[] = {
7529 (char *) "self", NULL
7530 };
7531
7532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
7533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7534 if (SWIG_arg_fail(1)) SWIG_fail;
7535 {
7536 PyThreadState* __tstate = wxPyBeginAllowThreads();
7537 (arg1)->Reset();
7538
7539 wxPyEndAllowThreads(__tstate);
7540 if (PyErr_Occurred()) SWIG_fail;
7541 }
7542 Py_INCREF(Py_None); resultobj = Py_None;
7543 return resultobj;
7544 fail:
7545 return NULL;
7546 }
7547
7548
7549 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
7550 PyObject *resultobj;
7551 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7552 PyObject * obj0 = 0 ;
7553 char *kwnames[] = {
7554 (char *) "self", NULL
7555 };
7556
7557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
7558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7559 if (SWIG_arg_fail(1)) SWIG_fail;
7560 {
7561 PyThreadState* __tstate = wxPyBeginAllowThreads();
7562 wxRegionIterator_Next(arg1);
7563
7564 wxPyEndAllowThreads(__tstate);
7565 if (PyErr_Occurred()) SWIG_fail;
7566 }
7567 Py_INCREF(Py_None); resultobj = Py_None;
7568 return resultobj;
7569 fail:
7570 return NULL;
7571 }
7572
7573
7574 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
7575 PyObject *resultobj;
7576 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7577 bool result;
7578 PyObject * obj0 = 0 ;
7579 char *kwnames[] = {
7580 (char *) "self", NULL
7581 };
7582
7583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
7584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7585 if (SWIG_arg_fail(1)) SWIG_fail;
7586 {
7587 PyThreadState* __tstate = wxPyBeginAllowThreads();
7588 result = (bool)wxRegionIterator___nonzero__(arg1);
7589
7590 wxPyEndAllowThreads(__tstate);
7591 if (PyErr_Occurred()) SWIG_fail;
7592 }
7593 {
7594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7595 }
7596 return resultobj;
7597 fail:
7598 return NULL;
7599 }
7600
7601
7602 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
7603 PyObject *obj;
7604 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7605 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
7606 Py_INCREF(obj);
7607 return Py_BuildValue((char *)"");
7608 }
7609 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7610 PyObject *resultobj;
7611 wxNativeFontInfo *result;
7612 char *kwnames[] = {
7613 NULL
7614 };
7615
7616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
7617 {
7618 PyThreadState* __tstate = wxPyBeginAllowThreads();
7619 result = (wxNativeFontInfo *)new wxNativeFontInfo();
7620
7621 wxPyEndAllowThreads(__tstate);
7622 if (PyErr_Occurred()) SWIG_fail;
7623 }
7624 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
7625 return resultobj;
7626 fail:
7627 return NULL;
7628 }
7629
7630
7631 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7632 PyObject *resultobj;
7633 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7634 PyObject * obj0 = 0 ;
7635 char *kwnames[] = {
7636 (char *) "self", NULL
7637 };
7638
7639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
7640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7641 if (SWIG_arg_fail(1)) SWIG_fail;
7642 {
7643 PyThreadState* __tstate = wxPyBeginAllowThreads();
7644 delete arg1;
7645
7646 wxPyEndAllowThreads(__tstate);
7647 if (PyErr_Occurred()) SWIG_fail;
7648 }
7649 Py_INCREF(Py_None); resultobj = Py_None;
7650 return resultobj;
7651 fail:
7652 return NULL;
7653 }
7654
7655
7656 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
7657 PyObject *resultobj;
7658 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7659 PyObject * obj0 = 0 ;
7660 char *kwnames[] = {
7661 (char *) "self", NULL
7662 };
7663
7664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
7665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7666 if (SWIG_arg_fail(1)) SWIG_fail;
7667 {
7668 PyThreadState* __tstate = wxPyBeginAllowThreads();
7669 (arg1)->Init();
7670
7671 wxPyEndAllowThreads(__tstate);
7672 if (PyErr_Occurred()) SWIG_fail;
7673 }
7674 Py_INCREF(Py_None); resultobj = Py_None;
7675 return resultobj;
7676 fail:
7677 return NULL;
7678 }
7679
7680
7681 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
7682 PyObject *resultobj;
7683 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7684 wxFont *arg2 = 0 ;
7685 PyObject * obj0 = 0 ;
7686 PyObject * obj1 = 0 ;
7687 char *kwnames[] = {
7688 (char *) "self",(char *) "font", NULL
7689 };
7690
7691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
7692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7693 if (SWIG_arg_fail(1)) SWIG_fail;
7694 {
7695 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
7696 if (SWIG_arg_fail(2)) SWIG_fail;
7697 if (arg2 == NULL) {
7698 SWIG_null_ref("wxFont");
7699 }
7700 if (SWIG_arg_fail(2)) SWIG_fail;
7701 }
7702 {
7703 PyThreadState* __tstate = wxPyBeginAllowThreads();
7704 (arg1)->InitFromFont((wxFont const &)*arg2);
7705
7706 wxPyEndAllowThreads(__tstate);
7707 if (PyErr_Occurred()) SWIG_fail;
7708 }
7709 Py_INCREF(Py_None); resultobj = Py_None;
7710 return resultobj;
7711 fail:
7712 return NULL;
7713 }
7714
7715
7716 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7717 PyObject *resultobj;
7718 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7719 int result;
7720 PyObject * obj0 = 0 ;
7721 char *kwnames[] = {
7722 (char *) "self", NULL
7723 };
7724
7725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
7726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7727 if (SWIG_arg_fail(1)) SWIG_fail;
7728 {
7729 PyThreadState* __tstate = wxPyBeginAllowThreads();
7730 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
7731
7732 wxPyEndAllowThreads(__tstate);
7733 if (PyErr_Occurred()) SWIG_fail;
7734 }
7735 {
7736 resultobj = SWIG_From_int((int)(result));
7737 }
7738 return resultobj;
7739 fail:
7740 return NULL;
7741 }
7742
7743
7744 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7745 PyObject *resultobj;
7746 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7747 wxFontStyle result;
7748 PyObject * obj0 = 0 ;
7749 char *kwnames[] = {
7750 (char *) "self", NULL
7751 };
7752
7753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
7754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7755 if (SWIG_arg_fail(1)) SWIG_fail;
7756 {
7757 PyThreadState* __tstate = wxPyBeginAllowThreads();
7758 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
7759
7760 wxPyEndAllowThreads(__tstate);
7761 if (PyErr_Occurred()) SWIG_fail;
7762 }
7763 resultobj = SWIG_From_int((result));
7764 return resultobj;
7765 fail:
7766 return NULL;
7767 }
7768
7769
7770 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7771 PyObject *resultobj;
7772 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7773 wxFontWeight result;
7774 PyObject * obj0 = 0 ;
7775 char *kwnames[] = {
7776 (char *) "self", NULL
7777 };
7778
7779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
7780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7781 if (SWIG_arg_fail(1)) SWIG_fail;
7782 {
7783 PyThreadState* __tstate = wxPyBeginAllowThreads();
7784 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
7785
7786 wxPyEndAllowThreads(__tstate);
7787 if (PyErr_Occurred()) SWIG_fail;
7788 }
7789 resultobj = SWIG_From_int((result));
7790 return resultobj;
7791 fail:
7792 return NULL;
7793 }
7794
7795
7796 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7797 PyObject *resultobj;
7798 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7799 bool result;
7800 PyObject * obj0 = 0 ;
7801 char *kwnames[] = {
7802 (char *) "self", NULL
7803 };
7804
7805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
7806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7807 if (SWIG_arg_fail(1)) SWIG_fail;
7808 {
7809 PyThreadState* __tstate = wxPyBeginAllowThreads();
7810 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
7811
7812 wxPyEndAllowThreads(__tstate);
7813 if (PyErr_Occurred()) SWIG_fail;
7814 }
7815 {
7816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7817 }
7818 return resultobj;
7819 fail:
7820 return NULL;
7821 }
7822
7823
7824 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7825 PyObject *resultobj;
7826 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7827 wxString result;
7828 PyObject * obj0 = 0 ;
7829 char *kwnames[] = {
7830 (char *) "self", NULL
7831 };
7832
7833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
7834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7835 if (SWIG_arg_fail(1)) SWIG_fail;
7836 {
7837 PyThreadState* __tstate = wxPyBeginAllowThreads();
7838 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
7839
7840 wxPyEndAllowThreads(__tstate);
7841 if (PyErr_Occurred()) SWIG_fail;
7842 }
7843 {
7844 #if wxUSE_UNICODE
7845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7846 #else
7847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7848 #endif
7849 }
7850 return resultobj;
7851 fail:
7852 return NULL;
7853 }
7854
7855
7856 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
7857 PyObject *resultobj;
7858 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7859 wxFontFamily result;
7860 PyObject * obj0 = 0 ;
7861 char *kwnames[] = {
7862 (char *) "self", NULL
7863 };
7864
7865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
7866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7867 if (SWIG_arg_fail(1)) SWIG_fail;
7868 {
7869 PyThreadState* __tstate = wxPyBeginAllowThreads();
7870 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
7871
7872 wxPyEndAllowThreads(__tstate);
7873 if (PyErr_Occurred()) SWIG_fail;
7874 }
7875 resultobj = SWIG_From_int((result));
7876 return resultobj;
7877 fail:
7878 return NULL;
7879 }
7880
7881
7882 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
7883 PyObject *resultobj;
7884 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7885 wxFontEncoding result;
7886 PyObject * obj0 = 0 ;
7887 char *kwnames[] = {
7888 (char *) "self", NULL
7889 };
7890
7891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
7892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7893 if (SWIG_arg_fail(1)) SWIG_fail;
7894 {
7895 PyThreadState* __tstate = wxPyBeginAllowThreads();
7896 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
7897
7898 wxPyEndAllowThreads(__tstate);
7899 if (PyErr_Occurred()) SWIG_fail;
7900 }
7901 resultobj = SWIG_From_int((result));
7902 return resultobj;
7903 fail:
7904 return NULL;
7905 }
7906
7907
7908 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7909 PyObject *resultobj;
7910 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7911 int arg2 ;
7912 PyObject * obj0 = 0 ;
7913 PyObject * obj1 = 0 ;
7914 char *kwnames[] = {
7915 (char *) "self",(char *) "pointsize", NULL
7916 };
7917
7918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
7919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7920 if (SWIG_arg_fail(1)) SWIG_fail;
7921 {
7922 arg2 = (int)(SWIG_As_int(obj1));
7923 if (SWIG_arg_fail(2)) SWIG_fail;
7924 }
7925 {
7926 PyThreadState* __tstate = wxPyBeginAllowThreads();
7927 (arg1)->SetPointSize(arg2);
7928
7929 wxPyEndAllowThreads(__tstate);
7930 if (PyErr_Occurred()) SWIG_fail;
7931 }
7932 Py_INCREF(Py_None); resultobj = Py_None;
7933 return resultobj;
7934 fail:
7935 return NULL;
7936 }
7937
7938
7939 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7940 PyObject *resultobj;
7941 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7942 wxFontStyle arg2 ;
7943 PyObject * obj0 = 0 ;
7944 PyObject * obj1 = 0 ;
7945 char *kwnames[] = {
7946 (char *) "self",(char *) "style", NULL
7947 };
7948
7949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
7950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7951 if (SWIG_arg_fail(1)) SWIG_fail;
7952 {
7953 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
7954 if (SWIG_arg_fail(2)) SWIG_fail;
7955 }
7956 {
7957 PyThreadState* __tstate = wxPyBeginAllowThreads();
7958 (arg1)->SetStyle((wxFontStyle )arg2);
7959
7960 wxPyEndAllowThreads(__tstate);
7961 if (PyErr_Occurred()) SWIG_fail;
7962 }
7963 Py_INCREF(Py_None); resultobj = Py_None;
7964 return resultobj;
7965 fail:
7966 return NULL;
7967 }
7968
7969
7970 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7971 PyObject *resultobj;
7972 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7973 wxFontWeight arg2 ;
7974 PyObject * obj0 = 0 ;
7975 PyObject * obj1 = 0 ;
7976 char *kwnames[] = {
7977 (char *) "self",(char *) "weight", NULL
7978 };
7979
7980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
7981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7982 if (SWIG_arg_fail(1)) SWIG_fail;
7983 {
7984 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
7985 if (SWIG_arg_fail(2)) SWIG_fail;
7986 }
7987 {
7988 PyThreadState* __tstate = wxPyBeginAllowThreads();
7989 (arg1)->SetWeight((wxFontWeight )arg2);
7990
7991 wxPyEndAllowThreads(__tstate);
7992 if (PyErr_Occurred()) SWIG_fail;
7993 }
7994 Py_INCREF(Py_None); resultobj = Py_None;
7995 return resultobj;
7996 fail:
7997 return NULL;
7998 }
7999
8000
8001 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8002 PyObject *resultobj;
8003 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8004 bool arg2 ;
8005 PyObject * obj0 = 0 ;
8006 PyObject * obj1 = 0 ;
8007 char *kwnames[] = {
8008 (char *) "self",(char *) "underlined", NULL
8009 };
8010
8011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
8012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8013 if (SWIG_arg_fail(1)) SWIG_fail;
8014 {
8015 arg2 = (bool)(SWIG_As_bool(obj1));
8016 if (SWIG_arg_fail(2)) SWIG_fail;
8017 }
8018 {
8019 PyThreadState* __tstate = wxPyBeginAllowThreads();
8020 (arg1)->SetUnderlined(arg2);
8021
8022 wxPyEndAllowThreads(__tstate);
8023 if (PyErr_Occurred()) SWIG_fail;
8024 }
8025 Py_INCREF(Py_None); resultobj = Py_None;
8026 return resultobj;
8027 fail:
8028 return NULL;
8029 }
8030
8031
8032 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8033 PyObject *resultobj;
8034 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8035 wxString arg2 ;
8036 PyObject * obj0 = 0 ;
8037 PyObject * obj1 = 0 ;
8038 char *kwnames[] = {
8039 (char *) "self",(char *) "facename", NULL
8040 };
8041
8042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
8043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8044 if (SWIG_arg_fail(1)) SWIG_fail;
8045 {
8046 wxString* sptr = wxString_in_helper(obj1);
8047 if (sptr == NULL) SWIG_fail;
8048 arg2 = *sptr;
8049 delete sptr;
8050 }
8051 {
8052 PyThreadState* __tstate = wxPyBeginAllowThreads();
8053 (arg1)->SetFaceName(arg2);
8054
8055 wxPyEndAllowThreads(__tstate);
8056 if (PyErr_Occurred()) SWIG_fail;
8057 }
8058 Py_INCREF(Py_None); resultobj = Py_None;
8059 return resultobj;
8060 fail:
8061 return NULL;
8062 }
8063
8064
8065 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8066 PyObject *resultobj;
8067 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8068 wxFontFamily arg2 ;
8069 PyObject * obj0 = 0 ;
8070 PyObject * obj1 = 0 ;
8071 char *kwnames[] = {
8072 (char *) "self",(char *) "family", NULL
8073 };
8074
8075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8077 if (SWIG_arg_fail(1)) SWIG_fail;
8078 {
8079 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8080 if (SWIG_arg_fail(2)) SWIG_fail;
8081 }
8082 {
8083 PyThreadState* __tstate = wxPyBeginAllowThreads();
8084 (arg1)->SetFamily((wxFontFamily )arg2);
8085
8086 wxPyEndAllowThreads(__tstate);
8087 if (PyErr_Occurred()) SWIG_fail;
8088 }
8089 Py_INCREF(Py_None); resultobj = Py_None;
8090 return resultobj;
8091 fail:
8092 return NULL;
8093 }
8094
8095
8096 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8097 PyObject *resultobj;
8098 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8099 wxFontEncoding arg2 ;
8100 PyObject * obj0 = 0 ;
8101 PyObject * obj1 = 0 ;
8102 char *kwnames[] = {
8103 (char *) "self",(char *) "encoding", NULL
8104 };
8105
8106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8108 if (SWIG_arg_fail(1)) SWIG_fail;
8109 {
8110 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8111 if (SWIG_arg_fail(2)) SWIG_fail;
8112 }
8113 {
8114 PyThreadState* __tstate = wxPyBeginAllowThreads();
8115 (arg1)->SetEncoding((wxFontEncoding )arg2);
8116
8117 wxPyEndAllowThreads(__tstate);
8118 if (PyErr_Occurred()) SWIG_fail;
8119 }
8120 Py_INCREF(Py_None); resultobj = Py_None;
8121 return resultobj;
8122 fail:
8123 return NULL;
8124 }
8125
8126
8127 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8128 PyObject *resultobj;
8129 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8130 wxString *arg2 = 0 ;
8131 bool result;
8132 bool temp2 = false ;
8133 PyObject * obj0 = 0 ;
8134 PyObject * obj1 = 0 ;
8135 char *kwnames[] = {
8136 (char *) "self",(char *) "s", NULL
8137 };
8138
8139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8141 if (SWIG_arg_fail(1)) SWIG_fail;
8142 {
8143 arg2 = wxString_in_helper(obj1);
8144 if (arg2 == NULL) SWIG_fail;
8145 temp2 = true;
8146 }
8147 {
8148 PyThreadState* __tstate = wxPyBeginAllowThreads();
8149 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8150
8151 wxPyEndAllowThreads(__tstate);
8152 if (PyErr_Occurred()) SWIG_fail;
8153 }
8154 {
8155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8156 }
8157 {
8158 if (temp2)
8159 delete arg2;
8160 }
8161 return resultobj;
8162 fail:
8163 {
8164 if (temp2)
8165 delete arg2;
8166 }
8167 return NULL;
8168 }
8169
8170
8171 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8172 PyObject *resultobj;
8173 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8174 wxString result;
8175 PyObject * obj0 = 0 ;
8176 char *kwnames[] = {
8177 (char *) "self", NULL
8178 };
8179
8180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8182 if (SWIG_arg_fail(1)) SWIG_fail;
8183 {
8184 PyThreadState* __tstate = wxPyBeginAllowThreads();
8185 result = ((wxNativeFontInfo const *)arg1)->ToString();
8186
8187 wxPyEndAllowThreads(__tstate);
8188 if (PyErr_Occurred()) SWIG_fail;
8189 }
8190 {
8191 #if wxUSE_UNICODE
8192 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8193 #else
8194 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8195 #endif
8196 }
8197 return resultobj;
8198 fail:
8199 return NULL;
8200 }
8201
8202
8203 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8204 PyObject *resultobj;
8205 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8206 wxString result;
8207 PyObject * obj0 = 0 ;
8208 char *kwnames[] = {
8209 (char *) "self", NULL
8210 };
8211
8212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8214 if (SWIG_arg_fail(1)) SWIG_fail;
8215 {
8216 PyThreadState* __tstate = wxPyBeginAllowThreads();
8217 result = wxNativeFontInfo___str__(arg1);
8218
8219 wxPyEndAllowThreads(__tstate);
8220 if (PyErr_Occurred()) SWIG_fail;
8221 }
8222 {
8223 #if wxUSE_UNICODE
8224 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8225 #else
8226 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8227 #endif
8228 }
8229 return resultobj;
8230 fail:
8231 return NULL;
8232 }
8233
8234
8235 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8236 PyObject *resultobj;
8237 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8238 wxString *arg2 = 0 ;
8239 bool result;
8240 bool temp2 = false ;
8241 PyObject * obj0 = 0 ;
8242 PyObject * obj1 = 0 ;
8243 char *kwnames[] = {
8244 (char *) "self",(char *) "s", NULL
8245 };
8246
8247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8249 if (SWIG_arg_fail(1)) SWIG_fail;
8250 {
8251 arg2 = wxString_in_helper(obj1);
8252 if (arg2 == NULL) SWIG_fail;
8253 temp2 = true;
8254 }
8255 {
8256 PyThreadState* __tstate = wxPyBeginAllowThreads();
8257 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8258
8259 wxPyEndAllowThreads(__tstate);
8260 if (PyErr_Occurred()) SWIG_fail;
8261 }
8262 {
8263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8264 }
8265 {
8266 if (temp2)
8267 delete arg2;
8268 }
8269 return resultobj;
8270 fail:
8271 {
8272 if (temp2)
8273 delete arg2;
8274 }
8275 return NULL;
8276 }
8277
8278
8279 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8280 PyObject *resultobj;
8281 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8282 wxString result;
8283 PyObject * obj0 = 0 ;
8284 char *kwnames[] = {
8285 (char *) "self", NULL
8286 };
8287
8288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8290 if (SWIG_arg_fail(1)) SWIG_fail;
8291 {
8292 PyThreadState* __tstate = wxPyBeginAllowThreads();
8293 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8294
8295 wxPyEndAllowThreads(__tstate);
8296 if (PyErr_Occurred()) SWIG_fail;
8297 }
8298 {
8299 #if wxUSE_UNICODE
8300 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8301 #else
8302 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8303 #endif
8304 }
8305 return resultobj;
8306 fail:
8307 return NULL;
8308 }
8309
8310
8311 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8312 PyObject *obj;
8313 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8314 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8315 Py_INCREF(obj);
8316 return Py_BuildValue((char *)"");
8317 }
8318 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8319 PyObject *resultobj;
8320 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8321 wxString *arg2 = (wxString *) 0 ;
8322 bool temp2 = false ;
8323 PyObject * obj0 = 0 ;
8324 PyObject * obj1 = 0 ;
8325 char *kwnames[] = {
8326 (char *) "self",(char *) "facename", NULL
8327 };
8328
8329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8331 if (SWIG_arg_fail(1)) SWIG_fail;
8332 {
8333 arg2 = wxString_in_helper(obj1);
8334 if (arg2 == NULL) SWIG_fail;
8335 temp2 = true;
8336 }
8337 if (arg1) (arg1)->facename = *arg2;
8338
8339 Py_INCREF(Py_None); resultobj = Py_None;
8340 {
8341 if (temp2)
8342 delete arg2;
8343 }
8344 return resultobj;
8345 fail:
8346 {
8347 if (temp2)
8348 delete arg2;
8349 }
8350 return NULL;
8351 }
8352
8353
8354 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8355 PyObject *resultobj;
8356 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8357 wxString *result;
8358 PyObject * obj0 = 0 ;
8359 char *kwnames[] = {
8360 (char *) "self", NULL
8361 };
8362
8363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
8364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8365 if (SWIG_arg_fail(1)) SWIG_fail;
8366 result = (wxString *)& ((arg1)->facename);
8367
8368 {
8369 #if wxUSE_UNICODE
8370 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8371 #else
8372 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8373 #endif
8374 }
8375 return resultobj;
8376 fail:
8377 return NULL;
8378 }
8379
8380
8381 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8382 PyObject *resultobj;
8383 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8384 wxFontEncoding arg2 ;
8385 PyObject * obj0 = 0 ;
8386 PyObject * obj1 = 0 ;
8387 char *kwnames[] = {
8388 (char *) "self",(char *) "encoding", NULL
8389 };
8390
8391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
8392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8393 if (SWIG_arg_fail(1)) SWIG_fail;
8394 {
8395 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8396 if (SWIG_arg_fail(2)) SWIG_fail;
8397 }
8398 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
8399
8400 Py_INCREF(Py_None); resultobj = Py_None;
8401 return resultobj;
8402 fail:
8403 return NULL;
8404 }
8405
8406
8407 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
8408 PyObject *resultobj;
8409 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8410 wxFontEncoding result;
8411 PyObject * obj0 = 0 ;
8412 char *kwnames[] = {
8413 (char *) "self", NULL
8414 };
8415
8416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
8417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8418 if (SWIG_arg_fail(1)) SWIG_fail;
8419 result = (wxFontEncoding) ((arg1)->encoding);
8420
8421 resultobj = SWIG_From_int((result));
8422 return resultobj;
8423 fail:
8424 return NULL;
8425 }
8426
8427
8428 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8429 PyObject *resultobj;
8430 wxNativeEncodingInfo *result;
8431 char *kwnames[] = {
8432 NULL
8433 };
8434
8435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
8436 {
8437 PyThreadState* __tstate = wxPyBeginAllowThreads();
8438 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
8439
8440 wxPyEndAllowThreads(__tstate);
8441 if (PyErr_Occurred()) SWIG_fail;
8442 }
8443 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
8444 return resultobj;
8445 fail:
8446 return NULL;
8447 }
8448
8449
8450 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8451 PyObject *resultobj;
8452 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8453 PyObject * obj0 = 0 ;
8454 char *kwnames[] = {
8455 (char *) "self", NULL
8456 };
8457
8458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
8459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8460 if (SWIG_arg_fail(1)) SWIG_fail;
8461 {
8462 PyThreadState* __tstate = wxPyBeginAllowThreads();
8463 delete arg1;
8464
8465 wxPyEndAllowThreads(__tstate);
8466 if (PyErr_Occurred()) SWIG_fail;
8467 }
8468 Py_INCREF(Py_None); resultobj = Py_None;
8469 return resultobj;
8470 fail:
8471 return NULL;
8472 }
8473
8474
8475 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8476 PyObject *resultobj;
8477 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8478 wxString *arg2 = 0 ;
8479 bool result;
8480 bool temp2 = false ;
8481 PyObject * obj0 = 0 ;
8482 PyObject * obj1 = 0 ;
8483 char *kwnames[] = {
8484 (char *) "self",(char *) "s", NULL
8485 };
8486
8487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8489 if (SWIG_arg_fail(1)) SWIG_fail;
8490 {
8491 arg2 = wxString_in_helper(obj1);
8492 if (arg2 == NULL) SWIG_fail;
8493 temp2 = true;
8494 }
8495 {
8496 PyThreadState* __tstate = wxPyBeginAllowThreads();
8497 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8498
8499 wxPyEndAllowThreads(__tstate);
8500 if (PyErr_Occurred()) SWIG_fail;
8501 }
8502 {
8503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8504 }
8505 {
8506 if (temp2)
8507 delete arg2;
8508 }
8509 return resultobj;
8510 fail:
8511 {
8512 if (temp2)
8513 delete arg2;
8514 }
8515 return NULL;
8516 }
8517
8518
8519 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8520 PyObject *resultobj;
8521 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8522 wxString result;
8523 PyObject * obj0 = 0 ;
8524 char *kwnames[] = {
8525 (char *) "self", NULL
8526 };
8527
8528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
8529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8530 if (SWIG_arg_fail(1)) SWIG_fail;
8531 {
8532 PyThreadState* __tstate = wxPyBeginAllowThreads();
8533 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
8534
8535 wxPyEndAllowThreads(__tstate);
8536 if (PyErr_Occurred()) SWIG_fail;
8537 }
8538 {
8539 #if wxUSE_UNICODE
8540 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8541 #else
8542 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8543 #endif
8544 }
8545 return resultobj;
8546 fail:
8547 return NULL;
8548 }
8549
8550
8551 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
8552 PyObject *obj;
8553 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8554 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
8555 Py_INCREF(obj);
8556 return Py_BuildValue((char *)"");
8557 }
8558 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8559 PyObject *resultobj;
8560 wxFontEncoding arg1 ;
8561 wxNativeEncodingInfo *result;
8562 PyObject * obj0 = 0 ;
8563 char *kwnames[] = {
8564 (char *) "encoding", NULL
8565 };
8566
8567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
8568 {
8569 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8570 if (SWIG_arg_fail(1)) SWIG_fail;
8571 }
8572 {
8573 PyThreadState* __tstate = wxPyBeginAllowThreads();
8574 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
8575
8576 wxPyEndAllowThreads(__tstate);
8577 if (PyErr_Occurred()) SWIG_fail;
8578 }
8579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
8580 return resultobj;
8581 fail:
8582 return NULL;
8583 }
8584
8585
8586 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8587 PyObject *resultobj;
8588 wxNativeEncodingInfo *arg1 = 0 ;
8589 bool result;
8590 PyObject * obj0 = 0 ;
8591 char *kwnames[] = {
8592 (char *) "info", NULL
8593 };
8594
8595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
8596 {
8597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8598 if (SWIG_arg_fail(1)) SWIG_fail;
8599 if (arg1 == NULL) {
8600 SWIG_null_ref("wxNativeEncodingInfo");
8601 }
8602 if (SWIG_arg_fail(1)) SWIG_fail;
8603 }
8604 {
8605 PyThreadState* __tstate = wxPyBeginAllowThreads();
8606 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
8607
8608 wxPyEndAllowThreads(__tstate);
8609 if (PyErr_Occurred()) SWIG_fail;
8610 }
8611 {
8612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8613 }
8614 return resultobj;
8615 fail:
8616 return NULL;
8617 }
8618
8619
8620 static PyObject *_wrap_new_FontMapper(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 *)":new_FontMapper",kwnames)) goto fail;
8628 {
8629 PyThreadState* __tstate = wxPyBeginAllowThreads();
8630 result = (wxFontMapper *)new wxFontMapper();
8631
8632 wxPyEndAllowThreads(__tstate);
8633 if (PyErr_Occurred()) SWIG_fail;
8634 }
8635 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
8636 return resultobj;
8637 fail:
8638 return NULL;
8639 }
8640
8641
8642 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8643 PyObject *resultobj;
8644 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8645 PyObject * obj0 = 0 ;
8646 char *kwnames[] = {
8647 (char *) "self", NULL
8648 };
8649
8650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
8651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8652 if (SWIG_arg_fail(1)) SWIG_fail;
8653 {
8654 PyThreadState* __tstate = wxPyBeginAllowThreads();
8655 delete arg1;
8656
8657 wxPyEndAllowThreads(__tstate);
8658 if (PyErr_Occurred()) SWIG_fail;
8659 }
8660 Py_INCREF(Py_None); resultobj = Py_None;
8661 return resultobj;
8662 fail:
8663 return NULL;
8664 }
8665
8666
8667 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
8668 PyObject *resultobj;
8669 wxFontMapper *result;
8670 char *kwnames[] = {
8671 NULL
8672 };
8673
8674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
8675 {
8676 PyThreadState* __tstate = wxPyBeginAllowThreads();
8677 result = (wxFontMapper *)wxFontMapper::Get();
8678
8679 wxPyEndAllowThreads(__tstate);
8680 if (PyErr_Occurred()) SWIG_fail;
8681 }
8682 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8683 return resultobj;
8684 fail:
8685 return NULL;
8686 }
8687
8688
8689 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
8690 PyObject *resultobj;
8691 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8692 wxFontMapper *result;
8693 PyObject * obj0 = 0 ;
8694 char *kwnames[] = {
8695 (char *) "mapper", NULL
8696 };
8697
8698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
8699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8700 if (SWIG_arg_fail(1)) SWIG_fail;
8701 {
8702 PyThreadState* __tstate = wxPyBeginAllowThreads();
8703 result = (wxFontMapper *)wxFontMapper::Set(arg1);
8704
8705 wxPyEndAllowThreads(__tstate);
8706 if (PyErr_Occurred()) SWIG_fail;
8707 }
8708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8709 return resultobj;
8710 fail:
8711 return NULL;
8712 }
8713
8714
8715 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8716 PyObject *resultobj;
8717 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8718 wxString *arg2 = 0 ;
8719 bool arg3 = (bool) true ;
8720 wxFontEncoding result;
8721 bool temp2 = false ;
8722 PyObject * obj0 = 0 ;
8723 PyObject * obj1 = 0 ;
8724 PyObject * obj2 = 0 ;
8725 char *kwnames[] = {
8726 (char *) "self",(char *) "charset",(char *) "interactive", NULL
8727 };
8728
8729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
8730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8731 if (SWIG_arg_fail(1)) SWIG_fail;
8732 {
8733 arg2 = wxString_in_helper(obj1);
8734 if (arg2 == NULL) SWIG_fail;
8735 temp2 = true;
8736 }
8737 if (obj2) {
8738 {
8739 arg3 = (bool)(SWIG_As_bool(obj2));
8740 if (SWIG_arg_fail(3)) SWIG_fail;
8741 }
8742 }
8743 {
8744 PyThreadState* __tstate = wxPyBeginAllowThreads();
8745 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
8746
8747 wxPyEndAllowThreads(__tstate);
8748 if (PyErr_Occurred()) SWIG_fail;
8749 }
8750 resultobj = SWIG_From_int((result));
8751 {
8752 if (temp2)
8753 delete arg2;
8754 }
8755 return resultobj;
8756 fail:
8757 {
8758 if (temp2)
8759 delete arg2;
8760 }
8761 return NULL;
8762 }
8763
8764
8765 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
8766 PyObject *resultobj;
8767 size_t result;
8768 char *kwnames[] = {
8769 NULL
8770 };
8771
8772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
8773 {
8774 PyThreadState* __tstate = wxPyBeginAllowThreads();
8775 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
8776
8777 wxPyEndAllowThreads(__tstate);
8778 if (PyErr_Occurred()) SWIG_fail;
8779 }
8780 {
8781 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8782 }
8783 return resultobj;
8784 fail:
8785 return NULL;
8786 }
8787
8788
8789 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8790 PyObject *resultobj;
8791 size_t arg1 ;
8792 wxFontEncoding result;
8793 PyObject * obj0 = 0 ;
8794 char *kwnames[] = {
8795 (char *) "n", NULL
8796 };
8797
8798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
8799 {
8800 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8801 if (SWIG_arg_fail(1)) SWIG_fail;
8802 }
8803 {
8804 PyThreadState* __tstate = wxPyBeginAllowThreads();
8805 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
8806
8807 wxPyEndAllowThreads(__tstate);
8808 if (PyErr_Occurred()) SWIG_fail;
8809 }
8810 resultobj = SWIG_From_int((result));
8811 return resultobj;
8812 fail:
8813 return NULL;
8814 }
8815
8816
8817 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
8818 PyObject *resultobj;
8819 wxFontEncoding arg1 ;
8820 wxString result;
8821 PyObject * obj0 = 0 ;
8822 char *kwnames[] = {
8823 (char *) "encoding", NULL
8824 };
8825
8826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
8827 {
8828 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8829 if (SWIG_arg_fail(1)) SWIG_fail;
8830 }
8831 {
8832 PyThreadState* __tstate = wxPyBeginAllowThreads();
8833 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
8834
8835 wxPyEndAllowThreads(__tstate);
8836 if (PyErr_Occurred()) SWIG_fail;
8837 }
8838 {
8839 #if wxUSE_UNICODE
8840 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8841 #else
8842 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8843 #endif
8844 }
8845 return resultobj;
8846 fail:
8847 return NULL;
8848 }
8849
8850
8851 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
8852 PyObject *resultobj;
8853 wxFontEncoding arg1 ;
8854 wxString result;
8855 PyObject * obj0 = 0 ;
8856 char *kwnames[] = {
8857 (char *) "encoding", NULL
8858 };
8859
8860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
8861 {
8862 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8863 if (SWIG_arg_fail(1)) SWIG_fail;
8864 }
8865 {
8866 PyThreadState* __tstate = wxPyBeginAllowThreads();
8867 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
8868
8869 wxPyEndAllowThreads(__tstate);
8870 if (PyErr_Occurred()) SWIG_fail;
8871 }
8872 {
8873 #if wxUSE_UNICODE
8874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8875 #else
8876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8877 #endif
8878 }
8879 return resultobj;
8880 fail:
8881 return NULL;
8882 }
8883
8884
8885 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
8886 PyObject *resultobj;
8887 wxString *arg1 = 0 ;
8888 wxFontEncoding result;
8889 bool temp1 = false ;
8890 PyObject * obj0 = 0 ;
8891 char *kwnames[] = {
8892 (char *) "name", NULL
8893 };
8894
8895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
8896 {
8897 arg1 = wxString_in_helper(obj0);
8898 if (arg1 == NULL) SWIG_fail;
8899 temp1 = true;
8900 }
8901 {
8902 PyThreadState* __tstate = wxPyBeginAllowThreads();
8903 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
8904
8905 wxPyEndAllowThreads(__tstate);
8906 if (PyErr_Occurred()) SWIG_fail;
8907 }
8908 resultobj = SWIG_From_int((result));
8909 {
8910 if (temp1)
8911 delete arg1;
8912 }
8913 return resultobj;
8914 fail:
8915 {
8916 if (temp1)
8917 delete arg1;
8918 }
8919 return NULL;
8920 }
8921
8922
8923 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
8924 PyObject *resultobj;
8925 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8926 wxConfigBase *arg2 = (wxConfigBase *) 0 ;
8927 PyObject * obj0 = 0 ;
8928 PyObject * obj1 = 0 ;
8929 char *kwnames[] = {
8930 (char *) "self",(char *) "config", NULL
8931 };
8932
8933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
8934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8935 if (SWIG_arg_fail(1)) SWIG_fail;
8936 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8937 if (SWIG_arg_fail(2)) SWIG_fail;
8938 {
8939 PyThreadState* __tstate = wxPyBeginAllowThreads();
8940 (arg1)->SetConfig(arg2);
8941
8942 wxPyEndAllowThreads(__tstate);
8943 if (PyErr_Occurred()) SWIG_fail;
8944 }
8945 Py_INCREF(Py_None); resultobj = Py_None;
8946 return resultobj;
8947 fail:
8948 return NULL;
8949 }
8950
8951
8952 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8953 PyObject *resultobj;
8954 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8955 wxString *arg2 = 0 ;
8956 bool temp2 = false ;
8957 PyObject * obj0 = 0 ;
8958 PyObject * obj1 = 0 ;
8959 char *kwnames[] = {
8960 (char *) "self",(char *) "prefix", NULL
8961 };
8962
8963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
8964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8965 if (SWIG_arg_fail(1)) SWIG_fail;
8966 {
8967 arg2 = wxString_in_helper(obj1);
8968 if (arg2 == NULL) SWIG_fail;
8969 temp2 = true;
8970 }
8971 {
8972 PyThreadState* __tstate = wxPyBeginAllowThreads();
8973 (arg1)->SetConfigPath((wxString const &)*arg2);
8974
8975 wxPyEndAllowThreads(__tstate);
8976 if (PyErr_Occurred()) SWIG_fail;
8977 }
8978 Py_INCREF(Py_None); resultobj = Py_None;
8979 {
8980 if (temp2)
8981 delete arg2;
8982 }
8983 return resultobj;
8984 fail:
8985 {
8986 if (temp2)
8987 delete arg2;
8988 }
8989 return NULL;
8990 }
8991
8992
8993 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8994 PyObject *resultobj;
8995 wxString result;
8996 char *kwnames[] = {
8997 NULL
8998 };
8999
9000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
9001 {
9002 PyThreadState* __tstate = wxPyBeginAllowThreads();
9003 result = wxFontMapper::GetDefaultConfigPath();
9004
9005 wxPyEndAllowThreads(__tstate);
9006 if (PyErr_Occurred()) SWIG_fail;
9007 }
9008 {
9009 #if wxUSE_UNICODE
9010 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9011 #else
9012 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9013 #endif
9014 }
9015 return resultobj;
9016 fail:
9017 return NULL;
9018 }
9019
9020
9021 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9022 PyObject *resultobj;
9023 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9024 wxFontEncoding arg2 ;
9025 wxString const &arg3_defvalue = wxPyEmptyString ;
9026 wxString *arg3 = (wxString *) &arg3_defvalue ;
9027 bool arg4 = (bool) true ;
9028 PyObject *result;
9029 bool temp3 = false ;
9030 PyObject * obj0 = 0 ;
9031 PyObject * obj1 = 0 ;
9032 PyObject * obj2 = 0 ;
9033 PyObject * obj3 = 0 ;
9034 char *kwnames[] = {
9035 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
9036 };
9037
9038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9040 if (SWIG_arg_fail(1)) SWIG_fail;
9041 {
9042 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9043 if (SWIG_arg_fail(2)) SWIG_fail;
9044 }
9045 if (obj2) {
9046 {
9047 arg3 = wxString_in_helper(obj2);
9048 if (arg3 == NULL) SWIG_fail;
9049 temp3 = true;
9050 }
9051 }
9052 if (obj3) {
9053 {
9054 arg4 = (bool)(SWIG_As_bool(obj3));
9055 if (SWIG_arg_fail(4)) SWIG_fail;
9056 }
9057 }
9058 {
9059 PyThreadState* __tstate = wxPyBeginAllowThreads();
9060 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9061
9062 wxPyEndAllowThreads(__tstate);
9063 if (PyErr_Occurred()) SWIG_fail;
9064 }
9065 resultobj = result;
9066 {
9067 if (temp3)
9068 delete arg3;
9069 }
9070 return resultobj;
9071 fail:
9072 {
9073 if (temp3)
9074 delete arg3;
9075 }
9076 return NULL;
9077 }
9078
9079
9080 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9081 PyObject *resultobj;
9082 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9083 wxFontEncoding arg2 ;
9084 wxString const &arg3_defvalue = wxPyEmptyString ;
9085 wxString *arg3 = (wxString *) &arg3_defvalue ;
9086 bool result;
9087 bool temp3 = false ;
9088 PyObject * obj0 = 0 ;
9089 PyObject * obj1 = 0 ;
9090 PyObject * obj2 = 0 ;
9091 char *kwnames[] = {
9092 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9093 };
9094
9095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9097 if (SWIG_arg_fail(1)) SWIG_fail;
9098 {
9099 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9100 if (SWIG_arg_fail(2)) SWIG_fail;
9101 }
9102 if (obj2) {
9103 {
9104 arg3 = wxString_in_helper(obj2);
9105 if (arg3 == NULL) SWIG_fail;
9106 temp3 = true;
9107 }
9108 }
9109 {
9110 PyThreadState* __tstate = wxPyBeginAllowThreads();
9111 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9112
9113 wxPyEndAllowThreads(__tstate);
9114 if (PyErr_Occurred()) SWIG_fail;
9115 }
9116 {
9117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9118 }
9119 {
9120 if (temp3)
9121 delete arg3;
9122 }
9123 return resultobj;
9124 fail:
9125 {
9126 if (temp3)
9127 delete arg3;
9128 }
9129 return NULL;
9130 }
9131
9132
9133 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9134 PyObject *resultobj;
9135 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9136 wxWindow *arg2 = (wxWindow *) 0 ;
9137 PyObject * obj0 = 0 ;
9138 PyObject * obj1 = 0 ;
9139 char *kwnames[] = {
9140 (char *) "self",(char *) "parent", NULL
9141 };
9142
9143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9145 if (SWIG_arg_fail(1)) SWIG_fail;
9146 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9147 if (SWIG_arg_fail(2)) SWIG_fail;
9148 {
9149 PyThreadState* __tstate = wxPyBeginAllowThreads();
9150 (arg1)->SetDialogParent(arg2);
9151
9152 wxPyEndAllowThreads(__tstate);
9153 if (PyErr_Occurred()) SWIG_fail;
9154 }
9155 Py_INCREF(Py_None); resultobj = Py_None;
9156 return resultobj;
9157 fail:
9158 return NULL;
9159 }
9160
9161
9162 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9163 PyObject *resultobj;
9164 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9165 wxString *arg2 = 0 ;
9166 bool temp2 = false ;
9167 PyObject * obj0 = 0 ;
9168 PyObject * obj1 = 0 ;
9169 char *kwnames[] = {
9170 (char *) "self",(char *) "title", NULL
9171 };
9172
9173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9175 if (SWIG_arg_fail(1)) SWIG_fail;
9176 {
9177 arg2 = wxString_in_helper(obj1);
9178 if (arg2 == NULL) SWIG_fail;
9179 temp2 = true;
9180 }
9181 {
9182 PyThreadState* __tstate = wxPyBeginAllowThreads();
9183 (arg1)->SetDialogTitle((wxString const &)*arg2);
9184
9185 wxPyEndAllowThreads(__tstate);
9186 if (PyErr_Occurred()) SWIG_fail;
9187 }
9188 Py_INCREF(Py_None); resultobj = Py_None;
9189 {
9190 if (temp2)
9191 delete arg2;
9192 }
9193 return resultobj;
9194 fail:
9195 {
9196 if (temp2)
9197 delete arg2;
9198 }
9199 return NULL;
9200 }
9201
9202
9203 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9204 PyObject *obj;
9205 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9206 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9207 Py_INCREF(obj);
9208 return Py_BuildValue((char *)"");
9209 }
9210 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9211 PyObject *resultobj;
9212 int arg1 ;
9213 int arg2 ;
9214 int arg3 ;
9215 int arg4 ;
9216 bool arg5 = (bool) false ;
9217 wxString const &arg6_defvalue = wxPyEmptyString ;
9218 wxString *arg6 = (wxString *) &arg6_defvalue ;
9219 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9220 wxFont *result;
9221 bool temp6 = false ;
9222 PyObject * obj0 = 0 ;
9223 PyObject * obj1 = 0 ;
9224 PyObject * obj2 = 0 ;
9225 PyObject * obj3 = 0 ;
9226 PyObject * obj4 = 0 ;
9227 PyObject * obj5 = 0 ;
9228 PyObject * obj6 = 0 ;
9229 char *kwnames[] = {
9230 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9231 };
9232
9233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9234 {
9235 arg1 = (int)(SWIG_As_int(obj0));
9236 if (SWIG_arg_fail(1)) SWIG_fail;
9237 }
9238 {
9239 arg2 = (int)(SWIG_As_int(obj1));
9240 if (SWIG_arg_fail(2)) SWIG_fail;
9241 }
9242 {
9243 arg3 = (int)(SWIG_As_int(obj2));
9244 if (SWIG_arg_fail(3)) SWIG_fail;
9245 }
9246 {
9247 arg4 = (int)(SWIG_As_int(obj3));
9248 if (SWIG_arg_fail(4)) SWIG_fail;
9249 }
9250 if (obj4) {
9251 {
9252 arg5 = (bool)(SWIG_As_bool(obj4));
9253 if (SWIG_arg_fail(5)) SWIG_fail;
9254 }
9255 }
9256 if (obj5) {
9257 {
9258 arg6 = wxString_in_helper(obj5);
9259 if (arg6 == NULL) SWIG_fail;
9260 temp6 = true;
9261 }
9262 }
9263 if (obj6) {
9264 {
9265 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9266 if (SWIG_arg_fail(7)) SWIG_fail;
9267 }
9268 }
9269 {
9270 if (!wxPyCheckForApp()) SWIG_fail;
9271 PyThreadState* __tstate = wxPyBeginAllowThreads();
9272 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9273
9274 wxPyEndAllowThreads(__tstate);
9275 if (PyErr_Occurred()) SWIG_fail;
9276 }
9277 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9278 {
9279 if (temp6)
9280 delete arg6;
9281 }
9282 return resultobj;
9283 fail:
9284 {
9285 if (temp6)
9286 delete arg6;
9287 }
9288 return NULL;
9289 }
9290
9291
9292 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9293 PyObject *resultobj;
9294 wxFont *arg1 = (wxFont *) 0 ;
9295 PyObject * obj0 = 0 ;
9296 char *kwnames[] = {
9297 (char *) "self", NULL
9298 };
9299
9300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9302 if (SWIG_arg_fail(1)) SWIG_fail;
9303 {
9304 PyThreadState* __tstate = wxPyBeginAllowThreads();
9305 delete arg1;
9306
9307 wxPyEndAllowThreads(__tstate);
9308 if (PyErr_Occurred()) SWIG_fail;
9309 }
9310 Py_INCREF(Py_None); resultobj = Py_None;
9311 return resultobj;
9312 fail:
9313 return NULL;
9314 }
9315
9316
9317 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9318 PyObject *resultobj;
9319 wxNativeFontInfo *arg1 = 0 ;
9320 wxFont *result;
9321 PyObject * obj0 = 0 ;
9322 char *kwnames[] = {
9323 (char *) "info", NULL
9324 };
9325
9326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9327 {
9328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9329 if (SWIG_arg_fail(1)) SWIG_fail;
9330 if (arg1 == NULL) {
9331 SWIG_null_ref("wxNativeFontInfo");
9332 }
9333 if (SWIG_arg_fail(1)) SWIG_fail;
9334 }
9335 {
9336 if (!wxPyCheckForApp()) SWIG_fail;
9337 PyThreadState* __tstate = wxPyBeginAllowThreads();
9338 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9339
9340 wxPyEndAllowThreads(__tstate);
9341 if (PyErr_Occurred()) SWIG_fail;
9342 }
9343 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9344 return resultobj;
9345 fail:
9346 return NULL;
9347 }
9348
9349
9350 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9351 PyObject *resultobj;
9352 wxString *arg1 = 0 ;
9353 wxFont *result;
9354 bool temp1 = false ;
9355 PyObject * obj0 = 0 ;
9356 char *kwnames[] = {
9357 (char *) "info", NULL
9358 };
9359
9360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9361 {
9362 arg1 = wxString_in_helper(obj0);
9363 if (arg1 == NULL) SWIG_fail;
9364 temp1 = true;
9365 }
9366 {
9367 if (!wxPyCheckForApp()) SWIG_fail;
9368 PyThreadState* __tstate = wxPyBeginAllowThreads();
9369 result = (wxFont *)new_wxFont((wxString const &)*arg1);
9370
9371 wxPyEndAllowThreads(__tstate);
9372 if (PyErr_Occurred()) SWIG_fail;
9373 }
9374 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9375 {
9376 if (temp1)
9377 delete arg1;
9378 }
9379 return resultobj;
9380 fail:
9381 {
9382 if (temp1)
9383 delete arg1;
9384 }
9385 return NULL;
9386 }
9387
9388
9389 static PyObject *_wrap_new_FFont(PyObject *, PyObject *args, PyObject *kwargs) {
9390 PyObject *resultobj;
9391 int arg1 ;
9392 wxFontFamily arg2 ;
9393 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9394 wxString const &arg4_defvalue = wxPyEmptyString ;
9395 wxString *arg4 = (wxString *) &arg4_defvalue ;
9396 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9397 wxFont *result;
9398 bool temp4 = false ;
9399 PyObject * obj0 = 0 ;
9400 PyObject * obj1 = 0 ;
9401 PyObject * obj2 = 0 ;
9402 PyObject * obj3 = 0 ;
9403 PyObject * obj4 = 0 ;
9404 char *kwnames[] = {
9405 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9406 };
9407
9408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9409 {
9410 arg1 = (int)(SWIG_As_int(obj0));
9411 if (SWIG_arg_fail(1)) SWIG_fail;
9412 }
9413 {
9414 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9415 if (SWIG_arg_fail(2)) SWIG_fail;
9416 }
9417 if (obj2) {
9418 {
9419 arg3 = (int)(SWIG_As_int(obj2));
9420 if (SWIG_arg_fail(3)) SWIG_fail;
9421 }
9422 }
9423 if (obj3) {
9424 {
9425 arg4 = wxString_in_helper(obj3);
9426 if (arg4 == NULL) SWIG_fail;
9427 temp4 = true;
9428 }
9429 }
9430 if (obj4) {
9431 {
9432 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9433 if (SWIG_arg_fail(5)) SWIG_fail;
9434 }
9435 }
9436 {
9437 if (!wxPyCheckForApp()) SWIG_fail;
9438 PyThreadState* __tstate = wxPyBeginAllowThreads();
9439 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9440
9441 wxPyEndAllowThreads(__tstate);
9442 if (PyErr_Occurred()) SWIG_fail;
9443 }
9444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9445 {
9446 if (temp4)
9447 delete arg4;
9448 }
9449 return resultobj;
9450 fail:
9451 {
9452 if (temp4)
9453 delete arg4;
9454 }
9455 return NULL;
9456 }
9457
9458
9459 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9460 PyObject *resultobj;
9461 wxSize *arg1 = 0 ;
9462 int arg2 ;
9463 int arg3 ;
9464 int arg4 ;
9465 bool arg5 = (bool) false ;
9466 wxString const &arg6_defvalue = wxEmptyString ;
9467 wxString *arg6 = (wxString *) &arg6_defvalue ;
9468 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9469 wxFont *result;
9470 wxSize temp1 ;
9471 bool temp6 = false ;
9472 PyObject * obj0 = 0 ;
9473 PyObject * obj1 = 0 ;
9474 PyObject * obj2 = 0 ;
9475 PyObject * obj3 = 0 ;
9476 PyObject * obj4 = 0 ;
9477 PyObject * obj5 = 0 ;
9478 PyObject * obj6 = 0 ;
9479 char *kwnames[] = {
9480 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
9481 };
9482
9483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9484 {
9485 arg1 = &temp1;
9486 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9487 }
9488 {
9489 arg2 = (int)(SWIG_As_int(obj1));
9490 if (SWIG_arg_fail(2)) SWIG_fail;
9491 }
9492 {
9493 arg3 = (int)(SWIG_As_int(obj2));
9494 if (SWIG_arg_fail(3)) SWIG_fail;
9495 }
9496 {
9497 arg4 = (int)(SWIG_As_int(obj3));
9498 if (SWIG_arg_fail(4)) SWIG_fail;
9499 }
9500 if (obj4) {
9501 {
9502 arg5 = (bool)(SWIG_As_bool(obj4));
9503 if (SWIG_arg_fail(5)) SWIG_fail;
9504 }
9505 }
9506 if (obj5) {
9507 {
9508 arg6 = wxString_in_helper(obj5);
9509 if (arg6 == NULL) SWIG_fail;
9510 temp6 = true;
9511 }
9512 }
9513 if (obj6) {
9514 {
9515 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9516 if (SWIG_arg_fail(7)) SWIG_fail;
9517 }
9518 }
9519 {
9520 if (!wxPyCheckForApp()) SWIG_fail;
9521 PyThreadState* __tstate = wxPyBeginAllowThreads();
9522 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9523
9524 wxPyEndAllowThreads(__tstate);
9525 if (PyErr_Occurred()) SWIG_fail;
9526 }
9527 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9528 {
9529 if (temp6)
9530 delete arg6;
9531 }
9532 return resultobj;
9533 fail:
9534 {
9535 if (temp6)
9536 delete arg6;
9537 }
9538 return NULL;
9539 }
9540
9541
9542 static PyObject *_wrap_new_FFontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9543 PyObject *resultobj;
9544 wxSize *arg1 = 0 ;
9545 wxFontFamily arg2 ;
9546 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9547 wxString const &arg4_defvalue = wxEmptyString ;
9548 wxString *arg4 = (wxString *) &arg4_defvalue ;
9549 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9550 wxFont *result;
9551 wxSize temp1 ;
9552 bool temp4 = false ;
9553 PyObject * obj0 = 0 ;
9554 PyObject * obj1 = 0 ;
9555 PyObject * obj2 = 0 ;
9556 PyObject * obj3 = 0 ;
9557 PyObject * obj4 = 0 ;
9558 char *kwnames[] = {
9559 (char *) "pixelSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9560 };
9561
9562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9563 {
9564 arg1 = &temp1;
9565 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9566 }
9567 {
9568 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9569 if (SWIG_arg_fail(2)) SWIG_fail;
9570 }
9571 if (obj2) {
9572 {
9573 arg3 = (int)(SWIG_As_int(obj2));
9574 if (SWIG_arg_fail(3)) SWIG_fail;
9575 }
9576 }
9577 if (obj3) {
9578 {
9579 arg4 = wxString_in_helper(obj3);
9580 if (arg4 == NULL) SWIG_fail;
9581 temp4 = true;
9582 }
9583 }
9584 if (obj4) {
9585 {
9586 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9587 if (SWIG_arg_fail(5)) SWIG_fail;
9588 }
9589 }
9590 {
9591 if (!wxPyCheckForApp()) SWIG_fail;
9592 PyThreadState* __tstate = wxPyBeginAllowThreads();
9593 result = (wxFont *)new_wxFont((wxSize const &)*arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9594
9595 wxPyEndAllowThreads(__tstate);
9596 if (PyErr_Occurred()) SWIG_fail;
9597 }
9598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9599 {
9600 if (temp4)
9601 delete arg4;
9602 }
9603 return resultobj;
9604 fail:
9605 {
9606 if (temp4)
9607 delete arg4;
9608 }
9609 return NULL;
9610 }
9611
9612
9613 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
9614 PyObject *resultobj;
9615 wxFont *arg1 = (wxFont *) 0 ;
9616 bool result;
9617 PyObject * obj0 = 0 ;
9618 char *kwnames[] = {
9619 (char *) "self", NULL
9620 };
9621
9622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
9623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9624 if (SWIG_arg_fail(1)) SWIG_fail;
9625 {
9626 PyThreadState* __tstate = wxPyBeginAllowThreads();
9627 result = (bool)((wxFont const *)arg1)->Ok();
9628
9629 wxPyEndAllowThreads(__tstate);
9630 if (PyErr_Occurred()) SWIG_fail;
9631 }
9632 {
9633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9634 }
9635 return resultobj;
9636 fail:
9637 return NULL;
9638 }
9639
9640
9641 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9642 PyObject *resultobj;
9643 wxFont *arg1 = (wxFont *) 0 ;
9644 wxFont *arg2 = (wxFont *) 0 ;
9645 bool result;
9646 PyObject * obj0 = 0 ;
9647 PyObject * obj1 = 0 ;
9648 char *kwnames[] = {
9649 (char *) "self",(char *) "other", NULL
9650 };
9651
9652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
9653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9654 if (SWIG_arg_fail(1)) SWIG_fail;
9655 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9656 if (SWIG_arg_fail(2)) SWIG_fail;
9657 {
9658 PyThreadState* __tstate = wxPyBeginAllowThreads();
9659 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
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___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9674 PyObject *resultobj;
9675 wxFont *arg1 = (wxFont *) 0 ;
9676 wxFont *arg2 = (wxFont *) 0 ;
9677 bool result;
9678 PyObject * obj0 = 0 ;
9679 PyObject * obj1 = 0 ;
9680 char *kwnames[] = {
9681 (char *) "self",(char *) "other", NULL
9682 };
9683
9684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
9685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9686 if (SWIG_arg_fail(1)) SWIG_fail;
9687 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9688 if (SWIG_arg_fail(2)) SWIG_fail;
9689 {
9690 PyThreadState* __tstate = wxPyBeginAllowThreads();
9691 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
9692
9693 wxPyEndAllowThreads(__tstate);
9694 if (PyErr_Occurred()) SWIG_fail;
9695 }
9696 {
9697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9698 }
9699 return resultobj;
9700 fail:
9701 return NULL;
9702 }
9703
9704
9705 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9706 PyObject *resultobj;
9707 wxFont *arg1 = (wxFont *) 0 ;
9708 int result;
9709 PyObject * obj0 = 0 ;
9710 char *kwnames[] = {
9711 (char *) "self", NULL
9712 };
9713
9714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
9715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9716 if (SWIG_arg_fail(1)) SWIG_fail;
9717 {
9718 PyThreadState* __tstate = wxPyBeginAllowThreads();
9719 result = (int)((wxFont const *)arg1)->GetPointSize();
9720
9721 wxPyEndAllowThreads(__tstate);
9722 if (PyErr_Occurred()) SWIG_fail;
9723 }
9724 {
9725 resultobj = SWIG_From_int((int)(result));
9726 }
9727 return resultobj;
9728 fail:
9729 return NULL;
9730 }
9731
9732
9733 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9734 PyObject *resultobj;
9735 wxFont *arg1 = (wxFont *) 0 ;
9736 wxSize result;
9737 PyObject * obj0 = 0 ;
9738 char *kwnames[] = {
9739 (char *) "self", NULL
9740 };
9741
9742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
9743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9744 if (SWIG_arg_fail(1)) SWIG_fail;
9745 {
9746 PyThreadState* __tstate = wxPyBeginAllowThreads();
9747 result = ((wxFont const *)arg1)->GetPixelSize();
9748
9749 wxPyEndAllowThreads(__tstate);
9750 if (PyErr_Occurred()) SWIG_fail;
9751 }
9752 {
9753 wxSize * resultptr;
9754 resultptr = new wxSize((wxSize &)(result));
9755 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
9756 }
9757 return resultobj;
9758 fail:
9759 return NULL;
9760 }
9761
9762
9763 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
9764 PyObject *resultobj;
9765 wxFont *arg1 = (wxFont *) 0 ;
9766 bool result;
9767 PyObject * obj0 = 0 ;
9768 char *kwnames[] = {
9769 (char *) "self", NULL
9770 };
9771
9772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
9773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9774 if (SWIG_arg_fail(1)) SWIG_fail;
9775 {
9776 PyThreadState* __tstate = wxPyBeginAllowThreads();
9777 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
9778
9779 wxPyEndAllowThreads(__tstate);
9780 if (PyErr_Occurred()) SWIG_fail;
9781 }
9782 {
9783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9784 }
9785 return resultobj;
9786 fail:
9787 return NULL;
9788 }
9789
9790
9791 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
9792 PyObject *resultobj;
9793 wxFont *arg1 = (wxFont *) 0 ;
9794 int result;
9795 PyObject * obj0 = 0 ;
9796 char *kwnames[] = {
9797 (char *) "self", NULL
9798 };
9799
9800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
9801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9802 if (SWIG_arg_fail(1)) SWIG_fail;
9803 {
9804 PyThreadState* __tstate = wxPyBeginAllowThreads();
9805 result = (int)((wxFont const *)arg1)->GetFamily();
9806
9807 wxPyEndAllowThreads(__tstate);
9808 if (PyErr_Occurred()) SWIG_fail;
9809 }
9810 {
9811 resultobj = SWIG_From_int((int)(result));
9812 }
9813 return resultobj;
9814 fail:
9815 return NULL;
9816 }
9817
9818
9819 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
9820 PyObject *resultobj;
9821 wxFont *arg1 = (wxFont *) 0 ;
9822 int result;
9823 PyObject * obj0 = 0 ;
9824 char *kwnames[] = {
9825 (char *) "self", NULL
9826 };
9827
9828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
9829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9830 if (SWIG_arg_fail(1)) SWIG_fail;
9831 {
9832 PyThreadState* __tstate = wxPyBeginAllowThreads();
9833 result = (int)((wxFont const *)arg1)->GetStyle();
9834
9835 wxPyEndAllowThreads(__tstate);
9836 if (PyErr_Occurred()) SWIG_fail;
9837 }
9838 {
9839 resultobj = SWIG_From_int((int)(result));
9840 }
9841 return resultobj;
9842 fail:
9843 return NULL;
9844 }
9845
9846
9847 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
9848 PyObject *resultobj;
9849 wxFont *arg1 = (wxFont *) 0 ;
9850 int result;
9851 PyObject * obj0 = 0 ;
9852 char *kwnames[] = {
9853 (char *) "self", NULL
9854 };
9855
9856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
9857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9858 if (SWIG_arg_fail(1)) SWIG_fail;
9859 {
9860 PyThreadState* __tstate = wxPyBeginAllowThreads();
9861 result = (int)((wxFont const *)arg1)->GetWeight();
9862
9863 wxPyEndAllowThreads(__tstate);
9864 if (PyErr_Occurred()) SWIG_fail;
9865 }
9866 {
9867 resultobj = SWIG_From_int((int)(result));
9868 }
9869 return resultobj;
9870 fail:
9871 return NULL;
9872 }
9873
9874
9875 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
9876 PyObject *resultobj;
9877 wxFont *arg1 = (wxFont *) 0 ;
9878 bool result;
9879 PyObject * obj0 = 0 ;
9880 char *kwnames[] = {
9881 (char *) "self", NULL
9882 };
9883
9884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
9885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9886 if (SWIG_arg_fail(1)) SWIG_fail;
9887 {
9888 PyThreadState* __tstate = wxPyBeginAllowThreads();
9889 result = (bool)((wxFont const *)arg1)->GetUnderlined();
9890
9891 wxPyEndAllowThreads(__tstate);
9892 if (PyErr_Occurred()) SWIG_fail;
9893 }
9894 {
9895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9896 }
9897 return resultobj;
9898 fail:
9899 return NULL;
9900 }
9901
9902
9903 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
9904 PyObject *resultobj;
9905 wxFont *arg1 = (wxFont *) 0 ;
9906 wxString result;
9907 PyObject * obj0 = 0 ;
9908 char *kwnames[] = {
9909 (char *) "self", NULL
9910 };
9911
9912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
9913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9914 if (SWIG_arg_fail(1)) SWIG_fail;
9915 {
9916 PyThreadState* __tstate = wxPyBeginAllowThreads();
9917 result = ((wxFont const *)arg1)->GetFaceName();
9918
9919 wxPyEndAllowThreads(__tstate);
9920 if (PyErr_Occurred()) SWIG_fail;
9921 }
9922 {
9923 #if wxUSE_UNICODE
9924 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9925 #else
9926 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9927 #endif
9928 }
9929 return resultobj;
9930 fail:
9931 return NULL;
9932 }
9933
9934
9935 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9936 PyObject *resultobj;
9937 wxFont *arg1 = (wxFont *) 0 ;
9938 wxFontEncoding result;
9939 PyObject * obj0 = 0 ;
9940 char *kwnames[] = {
9941 (char *) "self", NULL
9942 };
9943
9944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
9945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9946 if (SWIG_arg_fail(1)) SWIG_fail;
9947 {
9948 PyThreadState* __tstate = wxPyBeginAllowThreads();
9949 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
9950
9951 wxPyEndAllowThreads(__tstate);
9952 if (PyErr_Occurred()) SWIG_fail;
9953 }
9954 resultobj = SWIG_From_int((result));
9955 return resultobj;
9956 fail:
9957 return NULL;
9958 }
9959
9960
9961 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9962 PyObject *resultobj;
9963 wxFont *arg1 = (wxFont *) 0 ;
9964 wxNativeFontInfo *result;
9965 PyObject * obj0 = 0 ;
9966 char *kwnames[] = {
9967 (char *) "self", NULL
9968 };
9969
9970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
9971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9972 if (SWIG_arg_fail(1)) SWIG_fail;
9973 {
9974 PyThreadState* __tstate = wxPyBeginAllowThreads();
9975 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
9976
9977 wxPyEndAllowThreads(__tstate);
9978 if (PyErr_Occurred()) SWIG_fail;
9979 }
9980 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
9981 return resultobj;
9982 fail:
9983 return NULL;
9984 }
9985
9986
9987 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
9988 PyObject *resultobj;
9989 wxFont *arg1 = (wxFont *) 0 ;
9990 bool result;
9991 PyObject * obj0 = 0 ;
9992 char *kwnames[] = {
9993 (char *) "self", NULL
9994 };
9995
9996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
9997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9998 if (SWIG_arg_fail(1)) SWIG_fail;
9999 {
10000 PyThreadState* __tstate = wxPyBeginAllowThreads();
10001 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
10002
10003 wxPyEndAllowThreads(__tstate);
10004 if (PyErr_Occurred()) SWIG_fail;
10005 }
10006 {
10007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10008 }
10009 return resultobj;
10010 fail:
10011 return NULL;
10012 }
10013
10014
10015 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10016 PyObject *resultobj;
10017 wxFont *arg1 = (wxFont *) 0 ;
10018 wxString result;
10019 PyObject * obj0 = 0 ;
10020 char *kwnames[] = {
10021 (char *) "self", NULL
10022 };
10023
10024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
10025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10026 if (SWIG_arg_fail(1)) SWIG_fail;
10027 {
10028 PyThreadState* __tstate = wxPyBeginAllowThreads();
10029 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
10030
10031 wxPyEndAllowThreads(__tstate);
10032 if (PyErr_Occurred()) SWIG_fail;
10033 }
10034 {
10035 #if wxUSE_UNICODE
10036 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10037 #else
10038 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10039 #endif
10040 }
10041 return resultobj;
10042 fail:
10043 return NULL;
10044 }
10045
10046
10047 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10048 PyObject *resultobj;
10049 wxFont *arg1 = (wxFont *) 0 ;
10050 wxString result;
10051 PyObject * obj0 = 0 ;
10052 char *kwnames[] = {
10053 (char *) "self", NULL
10054 };
10055
10056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
10057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10058 if (SWIG_arg_fail(1)) SWIG_fail;
10059 {
10060 PyThreadState* __tstate = wxPyBeginAllowThreads();
10061 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
10062
10063 wxPyEndAllowThreads(__tstate);
10064 if (PyErr_Occurred()) SWIG_fail;
10065 }
10066 {
10067 #if wxUSE_UNICODE
10068 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10069 #else
10070 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10071 #endif
10072 }
10073 return resultobj;
10074 fail:
10075 return NULL;
10076 }
10077
10078
10079 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10080 PyObject *resultobj;
10081 wxFont *arg1 = (wxFont *) 0 ;
10082 int arg2 ;
10083 PyObject * obj0 = 0 ;
10084 PyObject * obj1 = 0 ;
10085 char *kwnames[] = {
10086 (char *) "self",(char *) "pointSize", NULL
10087 };
10088
10089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
10090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10091 if (SWIG_arg_fail(1)) SWIG_fail;
10092 {
10093 arg2 = (int)(SWIG_As_int(obj1));
10094 if (SWIG_arg_fail(2)) SWIG_fail;
10095 }
10096 {
10097 PyThreadState* __tstate = wxPyBeginAllowThreads();
10098 (arg1)->SetPointSize(arg2);
10099
10100 wxPyEndAllowThreads(__tstate);
10101 if (PyErr_Occurred()) SWIG_fail;
10102 }
10103 Py_INCREF(Py_None); resultobj = Py_None;
10104 return resultobj;
10105 fail:
10106 return NULL;
10107 }
10108
10109
10110 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10111 PyObject *resultobj;
10112 wxFont *arg1 = (wxFont *) 0 ;
10113 wxSize *arg2 = 0 ;
10114 wxSize temp2 ;
10115 PyObject * obj0 = 0 ;
10116 PyObject * obj1 = 0 ;
10117 char *kwnames[] = {
10118 (char *) "self",(char *) "pixelSize", NULL
10119 };
10120
10121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10123 if (SWIG_arg_fail(1)) SWIG_fail;
10124 {
10125 arg2 = &temp2;
10126 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10127 }
10128 {
10129 PyThreadState* __tstate = wxPyBeginAllowThreads();
10130 (arg1)->SetPixelSize((wxSize const &)*arg2);
10131
10132 wxPyEndAllowThreads(__tstate);
10133 if (PyErr_Occurred()) SWIG_fail;
10134 }
10135 Py_INCREF(Py_None); resultobj = Py_None;
10136 return resultobj;
10137 fail:
10138 return NULL;
10139 }
10140
10141
10142 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10143 PyObject *resultobj;
10144 wxFont *arg1 = (wxFont *) 0 ;
10145 int arg2 ;
10146 PyObject * obj0 = 0 ;
10147 PyObject * obj1 = 0 ;
10148 char *kwnames[] = {
10149 (char *) "self",(char *) "family", NULL
10150 };
10151
10152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10154 if (SWIG_arg_fail(1)) SWIG_fail;
10155 {
10156 arg2 = (int)(SWIG_As_int(obj1));
10157 if (SWIG_arg_fail(2)) SWIG_fail;
10158 }
10159 {
10160 PyThreadState* __tstate = wxPyBeginAllowThreads();
10161 (arg1)->SetFamily(arg2);
10162
10163 wxPyEndAllowThreads(__tstate);
10164 if (PyErr_Occurred()) SWIG_fail;
10165 }
10166 Py_INCREF(Py_None); resultobj = Py_None;
10167 return resultobj;
10168 fail:
10169 return NULL;
10170 }
10171
10172
10173 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10174 PyObject *resultobj;
10175 wxFont *arg1 = (wxFont *) 0 ;
10176 int arg2 ;
10177 PyObject * obj0 = 0 ;
10178 PyObject * obj1 = 0 ;
10179 char *kwnames[] = {
10180 (char *) "self",(char *) "style", NULL
10181 };
10182
10183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10185 if (SWIG_arg_fail(1)) SWIG_fail;
10186 {
10187 arg2 = (int)(SWIG_As_int(obj1));
10188 if (SWIG_arg_fail(2)) SWIG_fail;
10189 }
10190 {
10191 PyThreadState* __tstate = wxPyBeginAllowThreads();
10192 (arg1)->SetStyle(arg2);
10193
10194 wxPyEndAllowThreads(__tstate);
10195 if (PyErr_Occurred()) SWIG_fail;
10196 }
10197 Py_INCREF(Py_None); resultobj = Py_None;
10198 return resultobj;
10199 fail:
10200 return NULL;
10201 }
10202
10203
10204 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10205 PyObject *resultobj;
10206 wxFont *arg1 = (wxFont *) 0 ;
10207 int arg2 ;
10208 PyObject * obj0 = 0 ;
10209 PyObject * obj1 = 0 ;
10210 char *kwnames[] = {
10211 (char *) "self",(char *) "weight", NULL
10212 };
10213
10214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10216 if (SWIG_arg_fail(1)) SWIG_fail;
10217 {
10218 arg2 = (int)(SWIG_As_int(obj1));
10219 if (SWIG_arg_fail(2)) SWIG_fail;
10220 }
10221 {
10222 PyThreadState* __tstate = wxPyBeginAllowThreads();
10223 (arg1)->SetWeight(arg2);
10224
10225 wxPyEndAllowThreads(__tstate);
10226 if (PyErr_Occurred()) SWIG_fail;
10227 }
10228 Py_INCREF(Py_None); resultobj = Py_None;
10229 return resultobj;
10230 fail:
10231 return NULL;
10232 }
10233
10234
10235 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10236 PyObject *resultobj;
10237 wxFont *arg1 = (wxFont *) 0 ;
10238 wxString *arg2 = 0 ;
10239 bool temp2 = false ;
10240 PyObject * obj0 = 0 ;
10241 PyObject * obj1 = 0 ;
10242 char *kwnames[] = {
10243 (char *) "self",(char *) "faceName", NULL
10244 };
10245
10246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10248 if (SWIG_arg_fail(1)) SWIG_fail;
10249 {
10250 arg2 = wxString_in_helper(obj1);
10251 if (arg2 == NULL) SWIG_fail;
10252 temp2 = true;
10253 }
10254 {
10255 PyThreadState* __tstate = wxPyBeginAllowThreads();
10256 (arg1)->SetFaceName((wxString const &)*arg2);
10257
10258 wxPyEndAllowThreads(__tstate);
10259 if (PyErr_Occurred()) SWIG_fail;
10260 }
10261 Py_INCREF(Py_None); resultobj = Py_None;
10262 {
10263 if (temp2)
10264 delete arg2;
10265 }
10266 return resultobj;
10267 fail:
10268 {
10269 if (temp2)
10270 delete arg2;
10271 }
10272 return NULL;
10273 }
10274
10275
10276 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10277 PyObject *resultobj;
10278 wxFont *arg1 = (wxFont *) 0 ;
10279 bool arg2 ;
10280 PyObject * obj0 = 0 ;
10281 PyObject * obj1 = 0 ;
10282 char *kwnames[] = {
10283 (char *) "self",(char *) "underlined", NULL
10284 };
10285
10286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10288 if (SWIG_arg_fail(1)) SWIG_fail;
10289 {
10290 arg2 = (bool)(SWIG_As_bool(obj1));
10291 if (SWIG_arg_fail(2)) SWIG_fail;
10292 }
10293 {
10294 PyThreadState* __tstate = wxPyBeginAllowThreads();
10295 (arg1)->SetUnderlined(arg2);
10296
10297 wxPyEndAllowThreads(__tstate);
10298 if (PyErr_Occurred()) SWIG_fail;
10299 }
10300 Py_INCREF(Py_None); resultobj = Py_None;
10301 return resultobj;
10302 fail:
10303 return NULL;
10304 }
10305
10306
10307 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10308 PyObject *resultobj;
10309 wxFont *arg1 = (wxFont *) 0 ;
10310 wxFontEncoding arg2 ;
10311 PyObject * obj0 = 0 ;
10312 PyObject * obj1 = 0 ;
10313 char *kwnames[] = {
10314 (char *) "self",(char *) "encoding", NULL
10315 };
10316
10317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10319 if (SWIG_arg_fail(1)) SWIG_fail;
10320 {
10321 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10322 if (SWIG_arg_fail(2)) SWIG_fail;
10323 }
10324 {
10325 PyThreadState* __tstate = wxPyBeginAllowThreads();
10326 (arg1)->SetEncoding((wxFontEncoding )arg2);
10327
10328 wxPyEndAllowThreads(__tstate);
10329 if (PyErr_Occurred()) SWIG_fail;
10330 }
10331 Py_INCREF(Py_None); resultobj = Py_None;
10332 return resultobj;
10333 fail:
10334 return NULL;
10335 }
10336
10337
10338 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10339 PyObject *resultobj;
10340 wxFont *arg1 = (wxFont *) 0 ;
10341 wxNativeFontInfo *arg2 = 0 ;
10342 PyObject * obj0 = 0 ;
10343 PyObject * obj1 = 0 ;
10344 char *kwnames[] = {
10345 (char *) "self",(char *) "info", NULL
10346 };
10347
10348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10350 if (SWIG_arg_fail(1)) SWIG_fail;
10351 {
10352 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10353 if (SWIG_arg_fail(2)) SWIG_fail;
10354 if (arg2 == NULL) {
10355 SWIG_null_ref("wxNativeFontInfo");
10356 }
10357 if (SWIG_arg_fail(2)) SWIG_fail;
10358 }
10359 {
10360 PyThreadState* __tstate = wxPyBeginAllowThreads();
10361 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10362
10363 wxPyEndAllowThreads(__tstate);
10364 if (PyErr_Occurred()) SWIG_fail;
10365 }
10366 Py_INCREF(Py_None); resultobj = Py_None;
10367 return resultobj;
10368 fail:
10369 return NULL;
10370 }
10371
10372
10373 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10374 PyObject *resultobj;
10375 wxFont *arg1 = (wxFont *) 0 ;
10376 wxString *arg2 = 0 ;
10377 bool temp2 = false ;
10378 PyObject * obj0 = 0 ;
10379 PyObject * obj1 = 0 ;
10380 char *kwnames[] = {
10381 (char *) "self",(char *) "info", NULL
10382 };
10383
10384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10386 if (SWIG_arg_fail(1)) SWIG_fail;
10387 {
10388 arg2 = wxString_in_helper(obj1);
10389 if (arg2 == NULL) SWIG_fail;
10390 temp2 = true;
10391 }
10392 {
10393 PyThreadState* __tstate = wxPyBeginAllowThreads();
10394 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10395
10396 wxPyEndAllowThreads(__tstate);
10397 if (PyErr_Occurred()) SWIG_fail;
10398 }
10399 Py_INCREF(Py_None); resultobj = Py_None;
10400 {
10401 if (temp2)
10402 delete arg2;
10403 }
10404 return resultobj;
10405 fail:
10406 {
10407 if (temp2)
10408 delete arg2;
10409 }
10410 return NULL;
10411 }
10412
10413
10414 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10415 PyObject *resultobj;
10416 wxFont *arg1 = (wxFont *) 0 ;
10417 wxString *arg2 = 0 ;
10418 bool temp2 = false ;
10419 PyObject * obj0 = 0 ;
10420 PyObject * obj1 = 0 ;
10421 char *kwnames[] = {
10422 (char *) "self",(char *) "info", NULL
10423 };
10424
10425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10427 if (SWIG_arg_fail(1)) SWIG_fail;
10428 {
10429 arg2 = wxString_in_helper(obj1);
10430 if (arg2 == NULL) SWIG_fail;
10431 temp2 = true;
10432 }
10433 {
10434 PyThreadState* __tstate = wxPyBeginAllowThreads();
10435 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
10436
10437 wxPyEndAllowThreads(__tstate);
10438 if (PyErr_Occurred()) SWIG_fail;
10439 }
10440 Py_INCREF(Py_None); resultobj = Py_None;
10441 {
10442 if (temp2)
10443 delete arg2;
10444 }
10445 return resultobj;
10446 fail:
10447 {
10448 if (temp2)
10449 delete arg2;
10450 }
10451 return NULL;
10452 }
10453
10454
10455 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
10456 PyObject *resultobj;
10457 wxFont *arg1 = (wxFont *) 0 ;
10458 wxString result;
10459 PyObject * obj0 = 0 ;
10460 char *kwnames[] = {
10461 (char *) "self", NULL
10462 };
10463
10464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
10465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10466 if (SWIG_arg_fail(1)) SWIG_fail;
10467 {
10468 PyThreadState* __tstate = wxPyBeginAllowThreads();
10469 result = ((wxFont const *)arg1)->GetFamilyString();
10470
10471 wxPyEndAllowThreads(__tstate);
10472 if (PyErr_Occurred()) SWIG_fail;
10473 }
10474 {
10475 #if wxUSE_UNICODE
10476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10477 #else
10478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10479 #endif
10480 }
10481 return resultobj;
10482 fail:
10483 return NULL;
10484 }
10485
10486
10487 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
10488 PyObject *resultobj;
10489 wxFont *arg1 = (wxFont *) 0 ;
10490 wxString result;
10491 PyObject * obj0 = 0 ;
10492 char *kwnames[] = {
10493 (char *) "self", NULL
10494 };
10495
10496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
10497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10498 if (SWIG_arg_fail(1)) SWIG_fail;
10499 {
10500 PyThreadState* __tstate = wxPyBeginAllowThreads();
10501 result = ((wxFont const *)arg1)->GetStyleString();
10502
10503 wxPyEndAllowThreads(__tstate);
10504 if (PyErr_Occurred()) SWIG_fail;
10505 }
10506 {
10507 #if wxUSE_UNICODE
10508 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10509 #else
10510 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10511 #endif
10512 }
10513 return resultobj;
10514 fail:
10515 return NULL;
10516 }
10517
10518
10519 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
10520 PyObject *resultobj;
10521 wxFont *arg1 = (wxFont *) 0 ;
10522 wxString result;
10523 PyObject * obj0 = 0 ;
10524 char *kwnames[] = {
10525 (char *) "self", NULL
10526 };
10527
10528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
10529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10530 if (SWIG_arg_fail(1)) SWIG_fail;
10531 {
10532 PyThreadState* __tstate = wxPyBeginAllowThreads();
10533 result = ((wxFont const *)arg1)->GetWeightString();
10534
10535 wxPyEndAllowThreads(__tstate);
10536 if (PyErr_Occurred()) SWIG_fail;
10537 }
10538 {
10539 #if wxUSE_UNICODE
10540 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10541 #else
10542 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10543 #endif
10544 }
10545 return resultobj;
10546 fail:
10547 return NULL;
10548 }
10549
10550
10551 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10552 PyObject *resultobj;
10553 wxFont *arg1 = (wxFont *) 0 ;
10554 bool arg2 = (bool) true ;
10555 PyObject * obj0 = 0 ;
10556 PyObject * obj1 = 0 ;
10557 char *kwnames[] = {
10558 (char *) "self",(char *) "no", NULL
10559 };
10560
10561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
10562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10563 if (SWIG_arg_fail(1)) SWIG_fail;
10564 if (obj1) {
10565 {
10566 arg2 = (bool)(SWIG_As_bool(obj1));
10567 if (SWIG_arg_fail(2)) SWIG_fail;
10568 }
10569 }
10570 {
10571 PyThreadState* __tstate = wxPyBeginAllowThreads();
10572 (arg1)->SetNoAntiAliasing(arg2);
10573
10574 wxPyEndAllowThreads(__tstate);
10575 if (PyErr_Occurred()) SWIG_fail;
10576 }
10577 Py_INCREF(Py_None); resultobj = Py_None;
10578 return resultobj;
10579 fail:
10580 return NULL;
10581 }
10582
10583
10584 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10585 PyObject *resultobj;
10586 wxFont *arg1 = (wxFont *) 0 ;
10587 bool result;
10588 PyObject * obj0 = 0 ;
10589 char *kwnames[] = {
10590 (char *) "self", NULL
10591 };
10592
10593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
10594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10595 if (SWIG_arg_fail(1)) SWIG_fail;
10596 {
10597 PyThreadState* __tstate = wxPyBeginAllowThreads();
10598 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
10599
10600 wxPyEndAllowThreads(__tstate);
10601 if (PyErr_Occurred()) SWIG_fail;
10602 }
10603 {
10604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10605 }
10606 return resultobj;
10607 fail:
10608 return NULL;
10609 }
10610
10611
10612 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10613 PyObject *resultobj;
10614 wxFontEncoding result;
10615 char *kwnames[] = {
10616 NULL
10617 };
10618
10619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
10620 {
10621 if (!wxPyCheckForApp()) SWIG_fail;
10622 PyThreadState* __tstate = wxPyBeginAllowThreads();
10623 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
10624
10625 wxPyEndAllowThreads(__tstate);
10626 if (PyErr_Occurred()) SWIG_fail;
10627 }
10628 resultobj = SWIG_From_int((result));
10629 return resultobj;
10630 fail:
10631 return NULL;
10632 }
10633
10634
10635 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10636 PyObject *resultobj;
10637 wxFontEncoding arg1 ;
10638 PyObject * obj0 = 0 ;
10639 char *kwnames[] = {
10640 (char *) "encoding", NULL
10641 };
10642
10643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
10644 {
10645 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
10646 if (SWIG_arg_fail(1)) SWIG_fail;
10647 }
10648 {
10649 if (!wxPyCheckForApp()) SWIG_fail;
10650 PyThreadState* __tstate = wxPyBeginAllowThreads();
10651 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
10652
10653 wxPyEndAllowThreads(__tstate);
10654 if (PyErr_Occurred()) SWIG_fail;
10655 }
10656 Py_INCREF(Py_None); resultobj = Py_None;
10657 return resultobj;
10658 fail:
10659 return NULL;
10660 }
10661
10662
10663 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
10664 PyObject *obj;
10665 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10666 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
10667 Py_INCREF(obj);
10668 return Py_BuildValue((char *)"");
10669 }
10670 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10671 PyObject *resultobj;
10672 wxPyFontEnumerator *result;
10673 char *kwnames[] = {
10674 NULL
10675 };
10676
10677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
10678 {
10679 if (!wxPyCheckForApp()) SWIG_fail;
10680 PyThreadState* __tstate = wxPyBeginAllowThreads();
10681 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
10682
10683 wxPyEndAllowThreads(__tstate);
10684 if (PyErr_Occurred()) SWIG_fail;
10685 }
10686 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
10687 return resultobj;
10688 fail:
10689 return NULL;
10690 }
10691
10692
10693 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10694 PyObject *resultobj;
10695 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10696 PyObject * obj0 = 0 ;
10697 char *kwnames[] = {
10698 (char *) "self", NULL
10699 };
10700
10701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
10702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10703 if (SWIG_arg_fail(1)) SWIG_fail;
10704 {
10705 PyThreadState* __tstate = wxPyBeginAllowThreads();
10706 delete arg1;
10707
10708 wxPyEndAllowThreads(__tstate);
10709 if (PyErr_Occurred()) SWIG_fail;
10710 }
10711 Py_INCREF(Py_None); resultobj = Py_None;
10712 return resultobj;
10713 fail:
10714 return NULL;
10715 }
10716
10717
10718 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10719 PyObject *resultobj;
10720 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10721 PyObject *arg2 = (PyObject *) 0 ;
10722 PyObject *arg3 = (PyObject *) 0 ;
10723 bool arg4 ;
10724 PyObject * obj0 = 0 ;
10725 PyObject * obj1 = 0 ;
10726 PyObject * obj2 = 0 ;
10727 PyObject * obj3 = 0 ;
10728 char *kwnames[] = {
10729 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10730 };
10731
10732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10734 if (SWIG_arg_fail(1)) SWIG_fail;
10735 arg2 = obj1;
10736 arg3 = obj2;
10737 {
10738 arg4 = (bool)(SWIG_As_bool(obj3));
10739 if (SWIG_arg_fail(4)) SWIG_fail;
10740 }
10741 {
10742 PyThreadState* __tstate = wxPyBeginAllowThreads();
10743 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10744
10745 wxPyEndAllowThreads(__tstate);
10746 if (PyErr_Occurred()) SWIG_fail;
10747 }
10748 Py_INCREF(Py_None); resultobj = Py_None;
10749 return resultobj;
10750 fail:
10751 return NULL;
10752 }
10753
10754
10755 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10756 PyObject *resultobj;
10757 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10758 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
10759 bool arg3 = (bool) false ;
10760 bool result;
10761 PyObject * obj0 = 0 ;
10762 PyObject * obj1 = 0 ;
10763 PyObject * obj2 = 0 ;
10764 char *kwnames[] = {
10765 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
10766 };
10767
10768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
10769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10770 if (SWIG_arg_fail(1)) SWIG_fail;
10771 if (obj1) {
10772 {
10773 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10774 if (SWIG_arg_fail(2)) SWIG_fail;
10775 }
10776 }
10777 if (obj2) {
10778 {
10779 arg3 = (bool)(SWIG_As_bool(obj2));
10780 if (SWIG_arg_fail(3)) SWIG_fail;
10781 }
10782 }
10783 {
10784 PyThreadState* __tstate = wxPyBeginAllowThreads();
10785 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
10786
10787 wxPyEndAllowThreads(__tstate);
10788 if (PyErr_Occurred()) SWIG_fail;
10789 }
10790 {
10791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10792 }
10793 return resultobj;
10794 fail:
10795 return NULL;
10796 }
10797
10798
10799 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10800 PyObject *resultobj;
10801 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10802 wxString const &arg2_defvalue = wxPyEmptyString ;
10803 wxString *arg2 = (wxString *) &arg2_defvalue ;
10804 bool result;
10805 bool temp2 = false ;
10806 PyObject * obj0 = 0 ;
10807 PyObject * obj1 = 0 ;
10808 char *kwnames[] = {
10809 (char *) "self",(char *) "facename", NULL
10810 };
10811
10812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
10813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10814 if (SWIG_arg_fail(1)) SWIG_fail;
10815 if (obj1) {
10816 {
10817 arg2 = wxString_in_helper(obj1);
10818 if (arg2 == NULL) SWIG_fail;
10819 temp2 = true;
10820 }
10821 }
10822 {
10823 PyThreadState* __tstate = wxPyBeginAllowThreads();
10824 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
10825
10826 wxPyEndAllowThreads(__tstate);
10827 if (PyErr_Occurred()) SWIG_fail;
10828 }
10829 {
10830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10831 }
10832 {
10833 if (temp2)
10834 delete arg2;
10835 }
10836 return resultobj;
10837 fail:
10838 {
10839 if (temp2)
10840 delete arg2;
10841 }
10842 return NULL;
10843 }
10844
10845
10846 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10847 PyObject *resultobj;
10848 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10849 PyObject *result;
10850 PyObject * obj0 = 0 ;
10851 char *kwnames[] = {
10852 (char *) "self", NULL
10853 };
10854
10855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
10856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10857 if (SWIG_arg_fail(1)) SWIG_fail;
10858 {
10859 PyThreadState* __tstate = wxPyBeginAllowThreads();
10860 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
10861
10862 wxPyEndAllowThreads(__tstate);
10863 if (PyErr_Occurred()) SWIG_fail;
10864 }
10865 resultobj = result;
10866 return resultobj;
10867 fail:
10868 return NULL;
10869 }
10870
10871
10872 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10873 PyObject *resultobj;
10874 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10875 PyObject *result;
10876 PyObject * obj0 = 0 ;
10877 char *kwnames[] = {
10878 (char *) "self", NULL
10879 };
10880
10881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
10882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10883 if (SWIG_arg_fail(1)) SWIG_fail;
10884 {
10885 PyThreadState* __tstate = wxPyBeginAllowThreads();
10886 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
10887
10888 wxPyEndAllowThreads(__tstate);
10889 if (PyErr_Occurred()) SWIG_fail;
10890 }
10891 resultobj = result;
10892 return resultobj;
10893 fail:
10894 return NULL;
10895 }
10896
10897
10898 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
10899 PyObject *obj;
10900 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10901 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
10902 Py_INCREF(obj);
10903 return Py_BuildValue((char *)"");
10904 }
10905 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
10906 PyObject *resultobj;
10907 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10908 int arg2 ;
10909 PyObject * obj0 = 0 ;
10910 PyObject * obj1 = 0 ;
10911 char *kwnames[] = {
10912 (char *) "self",(char *) "Language", NULL
10913 };
10914
10915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
10916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10917 if (SWIG_arg_fail(1)) SWIG_fail;
10918 {
10919 arg2 = (int)(SWIG_As_int(obj1));
10920 if (SWIG_arg_fail(2)) SWIG_fail;
10921 }
10922 if (arg1) (arg1)->Language = arg2;
10923
10924 Py_INCREF(Py_None); resultobj = Py_None;
10925 return resultobj;
10926 fail:
10927 return NULL;
10928 }
10929
10930
10931 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
10932 PyObject *resultobj;
10933 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10934 int result;
10935 PyObject * obj0 = 0 ;
10936 char *kwnames[] = {
10937 (char *) "self", NULL
10938 };
10939
10940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
10941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10942 if (SWIG_arg_fail(1)) SWIG_fail;
10943 result = (int) ((arg1)->Language);
10944
10945 {
10946 resultobj = SWIG_From_int((int)(result));
10947 }
10948 return resultobj;
10949 fail:
10950 return NULL;
10951 }
10952
10953
10954 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
10955 PyObject *resultobj;
10956 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10957 wxString *arg2 = (wxString *) 0 ;
10958 bool temp2 = false ;
10959 PyObject * obj0 = 0 ;
10960 PyObject * obj1 = 0 ;
10961 char *kwnames[] = {
10962 (char *) "self",(char *) "CanonicalName", NULL
10963 };
10964
10965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
10966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10967 if (SWIG_arg_fail(1)) SWIG_fail;
10968 {
10969 arg2 = wxString_in_helper(obj1);
10970 if (arg2 == NULL) SWIG_fail;
10971 temp2 = true;
10972 }
10973 if (arg1) (arg1)->CanonicalName = *arg2;
10974
10975 Py_INCREF(Py_None); resultobj = Py_None;
10976 {
10977 if (temp2)
10978 delete arg2;
10979 }
10980 return resultobj;
10981 fail:
10982 {
10983 if (temp2)
10984 delete arg2;
10985 }
10986 return NULL;
10987 }
10988
10989
10990 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
10991 PyObject *resultobj;
10992 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10993 wxString *result;
10994 PyObject * obj0 = 0 ;
10995 char *kwnames[] = {
10996 (char *) "self", NULL
10997 };
10998
10999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
11000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11001 if (SWIG_arg_fail(1)) SWIG_fail;
11002 result = (wxString *)& ((arg1)->CanonicalName);
11003
11004 {
11005 #if wxUSE_UNICODE
11006 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11007 #else
11008 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11009 #endif
11010 }
11011 return resultobj;
11012 fail:
11013 return NULL;
11014 }
11015
11016
11017 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
11018 PyObject *resultobj;
11019 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11020 wxString *arg2 = (wxString *) 0 ;
11021 bool temp2 = false ;
11022 PyObject * obj0 = 0 ;
11023 PyObject * obj1 = 0 ;
11024 char *kwnames[] = {
11025 (char *) "self",(char *) "Description", NULL
11026 };
11027
11028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
11029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11030 if (SWIG_arg_fail(1)) SWIG_fail;
11031 {
11032 arg2 = wxString_in_helper(obj1);
11033 if (arg2 == NULL) SWIG_fail;
11034 temp2 = true;
11035 }
11036 if (arg1) (arg1)->Description = *arg2;
11037
11038 Py_INCREF(Py_None); resultobj = Py_None;
11039 {
11040 if (temp2)
11041 delete arg2;
11042 }
11043 return resultobj;
11044 fail:
11045 {
11046 if (temp2)
11047 delete arg2;
11048 }
11049 return NULL;
11050 }
11051
11052
11053 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
11054 PyObject *resultobj;
11055 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11056 wxString *result;
11057 PyObject * obj0 = 0 ;
11058 char *kwnames[] = {
11059 (char *) "self", NULL
11060 };
11061
11062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
11063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11064 if (SWIG_arg_fail(1)) SWIG_fail;
11065 result = (wxString *)& ((arg1)->Description);
11066
11067 {
11068 #if wxUSE_UNICODE
11069 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11070 #else
11071 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11072 #endif
11073 }
11074 return resultobj;
11075 fail:
11076 return NULL;
11077 }
11078
11079
11080 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
11081 PyObject *obj;
11082 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11083 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
11084 Py_INCREF(obj);
11085 return Py_BuildValue((char *)"");
11086 }
11087 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11088 PyObject *resultobj;
11089 int arg1 = (int) -1 ;
11090 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11091 wxLocale *result;
11092 PyObject * obj0 = 0 ;
11093 PyObject * obj1 = 0 ;
11094 char *kwnames[] = {
11095 (char *) "language",(char *) "flags", NULL
11096 };
11097
11098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
11099 if (obj0) {
11100 {
11101 arg1 = (int)(SWIG_As_int(obj0));
11102 if (SWIG_arg_fail(1)) SWIG_fail;
11103 }
11104 }
11105 if (obj1) {
11106 {
11107 arg2 = (int)(SWIG_As_int(obj1));
11108 if (SWIG_arg_fail(2)) SWIG_fail;
11109 }
11110 }
11111 {
11112 PyThreadState* __tstate = wxPyBeginAllowThreads();
11113 result = (wxLocale *)new_wxLocale(arg1,arg2);
11114
11115 wxPyEndAllowThreads(__tstate);
11116 if (PyErr_Occurred()) SWIG_fail;
11117 }
11118 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11119 return resultobj;
11120 fail:
11121 return NULL;
11122 }
11123
11124
11125 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11126 PyObject *resultobj;
11127 wxLocale *arg1 = (wxLocale *) 0 ;
11128 PyObject * obj0 = 0 ;
11129 char *kwnames[] = {
11130 (char *) "self", NULL
11131 };
11132
11133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11135 if (SWIG_arg_fail(1)) SWIG_fail;
11136 {
11137 PyThreadState* __tstate = wxPyBeginAllowThreads();
11138 delete arg1;
11139
11140 wxPyEndAllowThreads(__tstate);
11141 if (PyErr_Occurred()) SWIG_fail;
11142 }
11143 Py_INCREF(Py_None); resultobj = Py_None;
11144 return resultobj;
11145 fail:
11146 return NULL;
11147 }
11148
11149
11150 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11151 PyObject *resultobj;
11152 wxLocale *arg1 = (wxLocale *) 0 ;
11153 wxString *arg2 = 0 ;
11154 wxString const &arg3_defvalue = wxPyEmptyString ;
11155 wxString *arg3 = (wxString *) &arg3_defvalue ;
11156 wxString const &arg4_defvalue = wxPyEmptyString ;
11157 wxString *arg4 = (wxString *) &arg4_defvalue ;
11158 bool arg5 = (bool) true ;
11159 bool arg6 = (bool) false ;
11160 bool result;
11161 bool temp2 = false ;
11162 bool temp3 = false ;
11163 bool temp4 = false ;
11164 PyObject * obj0 = 0 ;
11165 PyObject * obj1 = 0 ;
11166 PyObject * obj2 = 0 ;
11167 PyObject * obj3 = 0 ;
11168 PyObject * obj4 = 0 ;
11169 PyObject * obj5 = 0 ;
11170 char *kwnames[] = {
11171 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11172 };
11173
11174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11176 if (SWIG_arg_fail(1)) SWIG_fail;
11177 {
11178 arg2 = wxString_in_helper(obj1);
11179 if (arg2 == NULL) SWIG_fail;
11180 temp2 = true;
11181 }
11182 if (obj2) {
11183 {
11184 arg3 = wxString_in_helper(obj2);
11185 if (arg3 == NULL) SWIG_fail;
11186 temp3 = true;
11187 }
11188 }
11189 if (obj3) {
11190 {
11191 arg4 = wxString_in_helper(obj3);
11192 if (arg4 == NULL) SWIG_fail;
11193 temp4 = true;
11194 }
11195 }
11196 if (obj4) {
11197 {
11198 arg5 = (bool)(SWIG_As_bool(obj4));
11199 if (SWIG_arg_fail(5)) SWIG_fail;
11200 }
11201 }
11202 if (obj5) {
11203 {
11204 arg6 = (bool)(SWIG_As_bool(obj5));
11205 if (SWIG_arg_fail(6)) SWIG_fail;
11206 }
11207 }
11208 {
11209 PyThreadState* __tstate = wxPyBeginAllowThreads();
11210 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11211
11212 wxPyEndAllowThreads(__tstate);
11213 if (PyErr_Occurred()) SWIG_fail;
11214 }
11215 {
11216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11217 }
11218 {
11219 if (temp2)
11220 delete arg2;
11221 }
11222 {
11223 if (temp3)
11224 delete arg3;
11225 }
11226 {
11227 if (temp4)
11228 delete arg4;
11229 }
11230 return resultobj;
11231 fail:
11232 {
11233 if (temp2)
11234 delete arg2;
11235 }
11236 {
11237 if (temp3)
11238 delete arg3;
11239 }
11240 {
11241 if (temp4)
11242 delete arg4;
11243 }
11244 return NULL;
11245 }
11246
11247
11248 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11249 PyObject *resultobj;
11250 wxLocale *arg1 = (wxLocale *) 0 ;
11251 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11252 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11253 bool result;
11254 PyObject * obj0 = 0 ;
11255 PyObject * obj1 = 0 ;
11256 PyObject * obj2 = 0 ;
11257 char *kwnames[] = {
11258 (char *) "self",(char *) "language",(char *) "flags", NULL
11259 };
11260
11261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11263 if (SWIG_arg_fail(1)) SWIG_fail;
11264 if (obj1) {
11265 {
11266 arg2 = (int)(SWIG_As_int(obj1));
11267 if (SWIG_arg_fail(2)) SWIG_fail;
11268 }
11269 }
11270 if (obj2) {
11271 {
11272 arg3 = (int)(SWIG_As_int(obj2));
11273 if (SWIG_arg_fail(3)) SWIG_fail;
11274 }
11275 }
11276 {
11277 PyThreadState* __tstate = wxPyBeginAllowThreads();
11278 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11279
11280 wxPyEndAllowThreads(__tstate);
11281 if (PyErr_Occurred()) SWIG_fail;
11282 }
11283 {
11284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11285 }
11286 return resultobj;
11287 fail:
11288 return NULL;
11289 }
11290
11291
11292 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11293 PyObject *resultobj;
11294 int result;
11295 char *kwnames[] = {
11296 NULL
11297 };
11298
11299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11300 {
11301 PyThreadState* __tstate = wxPyBeginAllowThreads();
11302 result = (int)wxLocale::GetSystemLanguage();
11303
11304 wxPyEndAllowThreads(__tstate);
11305 if (PyErr_Occurred()) SWIG_fail;
11306 }
11307 {
11308 resultobj = SWIG_From_int((int)(result));
11309 }
11310 return resultobj;
11311 fail:
11312 return NULL;
11313 }
11314
11315
11316 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11317 PyObject *resultobj;
11318 wxFontEncoding result;
11319 char *kwnames[] = {
11320 NULL
11321 };
11322
11323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11324 {
11325 PyThreadState* __tstate = wxPyBeginAllowThreads();
11326 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11327
11328 wxPyEndAllowThreads(__tstate);
11329 if (PyErr_Occurred()) SWIG_fail;
11330 }
11331 resultobj = SWIG_From_int((result));
11332 return resultobj;
11333 fail:
11334 return NULL;
11335 }
11336
11337
11338 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11339 PyObject *resultobj;
11340 wxString result;
11341 char *kwnames[] = {
11342 NULL
11343 };
11344
11345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11346 {
11347 PyThreadState* __tstate = wxPyBeginAllowThreads();
11348 result = wxLocale::GetSystemEncodingName();
11349
11350 wxPyEndAllowThreads(__tstate);
11351 if (PyErr_Occurred()) SWIG_fail;
11352 }
11353 {
11354 #if wxUSE_UNICODE
11355 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11356 #else
11357 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11358 #endif
11359 }
11360 return resultobj;
11361 fail:
11362 return NULL;
11363 }
11364
11365
11366 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11367 PyObject *resultobj;
11368 wxLocale *arg1 = (wxLocale *) 0 ;
11369 bool result;
11370 PyObject * obj0 = 0 ;
11371 char *kwnames[] = {
11372 (char *) "self", NULL
11373 };
11374
11375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11377 if (SWIG_arg_fail(1)) SWIG_fail;
11378 {
11379 PyThreadState* __tstate = wxPyBeginAllowThreads();
11380 result = (bool)((wxLocale const *)arg1)->IsOk();
11381
11382 wxPyEndAllowThreads(__tstate);
11383 if (PyErr_Occurred()) SWIG_fail;
11384 }
11385 {
11386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11387 }
11388 return resultobj;
11389 fail:
11390 return NULL;
11391 }
11392
11393
11394 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11395 PyObject *resultobj;
11396 wxLocale *arg1 = (wxLocale *) 0 ;
11397 wxString result;
11398 PyObject * obj0 = 0 ;
11399 char *kwnames[] = {
11400 (char *) "self", NULL
11401 };
11402
11403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11405 if (SWIG_arg_fail(1)) SWIG_fail;
11406 {
11407 PyThreadState* __tstate = wxPyBeginAllowThreads();
11408 result = ((wxLocale const *)arg1)->GetLocale();
11409
11410 wxPyEndAllowThreads(__tstate);
11411 if (PyErr_Occurred()) SWIG_fail;
11412 }
11413 {
11414 #if wxUSE_UNICODE
11415 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11416 #else
11417 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11418 #endif
11419 }
11420 return resultobj;
11421 fail:
11422 return NULL;
11423 }
11424
11425
11426 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11427 PyObject *resultobj;
11428 wxLocale *arg1 = (wxLocale *) 0 ;
11429 int result;
11430 PyObject * obj0 = 0 ;
11431 char *kwnames[] = {
11432 (char *) "self", NULL
11433 };
11434
11435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
11436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11437 if (SWIG_arg_fail(1)) SWIG_fail;
11438 {
11439 PyThreadState* __tstate = wxPyBeginAllowThreads();
11440 result = (int)((wxLocale const *)arg1)->GetLanguage();
11441
11442 wxPyEndAllowThreads(__tstate);
11443 if (PyErr_Occurred()) SWIG_fail;
11444 }
11445 {
11446 resultobj = SWIG_From_int((int)(result));
11447 }
11448 return resultobj;
11449 fail:
11450 return NULL;
11451 }
11452
11453
11454 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
11455 PyObject *resultobj;
11456 wxLocale *arg1 = (wxLocale *) 0 ;
11457 wxString result;
11458 PyObject * obj0 = 0 ;
11459 char *kwnames[] = {
11460 (char *) "self", NULL
11461 };
11462
11463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
11464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11465 if (SWIG_arg_fail(1)) SWIG_fail;
11466 {
11467 PyThreadState* __tstate = wxPyBeginAllowThreads();
11468 result = ((wxLocale const *)arg1)->GetSysName();
11469
11470 wxPyEndAllowThreads(__tstate);
11471 if (PyErr_Occurred()) SWIG_fail;
11472 }
11473 {
11474 #if wxUSE_UNICODE
11475 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11476 #else
11477 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11478 #endif
11479 }
11480 return resultobj;
11481 fail:
11482 return NULL;
11483 }
11484
11485
11486 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
11487 PyObject *resultobj;
11488 wxLocale *arg1 = (wxLocale *) 0 ;
11489 wxString result;
11490 PyObject * obj0 = 0 ;
11491 char *kwnames[] = {
11492 (char *) "self", NULL
11493 };
11494
11495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
11496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11497 if (SWIG_arg_fail(1)) SWIG_fail;
11498 {
11499 PyThreadState* __tstate = wxPyBeginAllowThreads();
11500 result = ((wxLocale const *)arg1)->GetCanonicalName();
11501
11502 wxPyEndAllowThreads(__tstate);
11503 if (PyErr_Occurred()) SWIG_fail;
11504 }
11505 {
11506 #if wxUSE_UNICODE
11507 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11508 #else
11509 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11510 #endif
11511 }
11512 return resultobj;
11513 fail:
11514 return NULL;
11515 }
11516
11517
11518 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
11519 PyObject *resultobj;
11520 wxString *arg1 = 0 ;
11521 bool temp1 = false ;
11522 PyObject * obj0 = 0 ;
11523 char *kwnames[] = {
11524 (char *) "prefix", NULL
11525 };
11526
11527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
11528 {
11529 arg1 = wxString_in_helper(obj0);
11530 if (arg1 == NULL) SWIG_fail;
11531 temp1 = true;
11532 }
11533 {
11534 PyThreadState* __tstate = wxPyBeginAllowThreads();
11535 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
11536
11537 wxPyEndAllowThreads(__tstate);
11538 if (PyErr_Occurred()) SWIG_fail;
11539 }
11540 Py_INCREF(Py_None); resultobj = Py_None;
11541 {
11542 if (temp1)
11543 delete arg1;
11544 }
11545 return resultobj;
11546 fail:
11547 {
11548 if (temp1)
11549 delete arg1;
11550 }
11551 return NULL;
11552 }
11553
11554
11555 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
11556 PyObject *resultobj;
11557 wxLocale *arg1 = (wxLocale *) 0 ;
11558 wxString *arg2 = 0 ;
11559 bool result;
11560 bool temp2 = false ;
11561 PyObject * obj0 = 0 ;
11562 PyObject * obj1 = 0 ;
11563 char *kwnames[] = {
11564 (char *) "self",(char *) "szDomain", NULL
11565 };
11566
11567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
11568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11569 if (SWIG_arg_fail(1)) SWIG_fail;
11570 {
11571 arg2 = wxString_in_helper(obj1);
11572 if (arg2 == NULL) SWIG_fail;
11573 temp2 = true;
11574 }
11575 {
11576 PyThreadState* __tstate = wxPyBeginAllowThreads();
11577 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
11578
11579 wxPyEndAllowThreads(__tstate);
11580 if (PyErr_Occurred()) SWIG_fail;
11581 }
11582 {
11583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11584 }
11585 {
11586 if (temp2)
11587 delete arg2;
11588 }
11589 return resultobj;
11590 fail:
11591 {
11592 if (temp2)
11593 delete arg2;
11594 }
11595 return NULL;
11596 }
11597
11598
11599 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
11600 PyObject *resultobj;
11601 wxLocale *arg1 = (wxLocale *) 0 ;
11602 wxString *arg2 = 0 ;
11603 bool result;
11604 bool temp2 = false ;
11605 PyObject * obj0 = 0 ;
11606 PyObject * obj1 = 0 ;
11607 char *kwnames[] = {
11608 (char *) "self",(char *) "szDomain", NULL
11609 };
11610
11611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
11612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11613 if (SWIG_arg_fail(1)) SWIG_fail;
11614 {
11615 arg2 = wxString_in_helper(obj1);
11616 if (arg2 == NULL) SWIG_fail;
11617 temp2 = true;
11618 }
11619 {
11620 PyThreadState* __tstate = wxPyBeginAllowThreads();
11621 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
11622
11623 wxPyEndAllowThreads(__tstate);
11624 if (PyErr_Occurred()) SWIG_fail;
11625 }
11626 {
11627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11628 }
11629 {
11630 if (temp2)
11631 delete arg2;
11632 }
11633 return resultobj;
11634 fail:
11635 {
11636 if (temp2)
11637 delete arg2;
11638 }
11639 return NULL;
11640 }
11641
11642
11643 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11644 PyObject *resultobj;
11645 int arg1 ;
11646 wxLanguageInfo *result;
11647 PyObject * obj0 = 0 ;
11648 char *kwnames[] = {
11649 (char *) "lang", NULL
11650 };
11651
11652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
11653 {
11654 arg1 = (int)(SWIG_As_int(obj0));
11655 if (SWIG_arg_fail(1)) SWIG_fail;
11656 }
11657 {
11658 PyThreadState* __tstate = wxPyBeginAllowThreads();
11659 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
11660
11661 wxPyEndAllowThreads(__tstate);
11662 if (PyErr_Occurred()) SWIG_fail;
11663 }
11664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11665 return resultobj;
11666 fail:
11667 return NULL;
11668 }
11669
11670
11671 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
11672 PyObject *resultobj;
11673 int arg1 ;
11674 wxString result;
11675 PyObject * obj0 = 0 ;
11676 char *kwnames[] = {
11677 (char *) "lang", NULL
11678 };
11679
11680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
11681 {
11682 arg1 = (int)(SWIG_As_int(obj0));
11683 if (SWIG_arg_fail(1)) SWIG_fail;
11684 }
11685 {
11686 PyThreadState* __tstate = wxPyBeginAllowThreads();
11687 result = wxLocale::GetLanguageName(arg1);
11688
11689 wxPyEndAllowThreads(__tstate);
11690 if (PyErr_Occurred()) SWIG_fail;
11691 }
11692 {
11693 #if wxUSE_UNICODE
11694 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11695 #else
11696 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11697 #endif
11698 }
11699 return resultobj;
11700 fail:
11701 return NULL;
11702 }
11703
11704
11705 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11706 PyObject *resultobj;
11707 wxString *arg1 = 0 ;
11708 wxLanguageInfo *result;
11709 bool temp1 = false ;
11710 PyObject * obj0 = 0 ;
11711 char *kwnames[] = {
11712 (char *) "locale", NULL
11713 };
11714
11715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
11716 {
11717 arg1 = wxString_in_helper(obj0);
11718 if (arg1 == NULL) SWIG_fail;
11719 temp1 = true;
11720 }
11721 {
11722 PyThreadState* __tstate = wxPyBeginAllowThreads();
11723 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
11724
11725 wxPyEndAllowThreads(__tstate);
11726 if (PyErr_Occurred()) SWIG_fail;
11727 }
11728 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11729 {
11730 if (temp1)
11731 delete arg1;
11732 }
11733 return resultobj;
11734 fail:
11735 {
11736 if (temp1)
11737 delete arg1;
11738 }
11739 return NULL;
11740 }
11741
11742
11743 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11744 PyObject *resultobj;
11745 wxLanguageInfo *arg1 = 0 ;
11746 PyObject * obj0 = 0 ;
11747 char *kwnames[] = {
11748 (char *) "info", NULL
11749 };
11750
11751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
11752 {
11753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11754 if (SWIG_arg_fail(1)) SWIG_fail;
11755 if (arg1 == NULL) {
11756 SWIG_null_ref("wxLanguageInfo");
11757 }
11758 if (SWIG_arg_fail(1)) SWIG_fail;
11759 }
11760 {
11761 PyThreadState* __tstate = wxPyBeginAllowThreads();
11762 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
11763
11764 wxPyEndAllowThreads(__tstate);
11765 if (PyErr_Occurred()) SWIG_fail;
11766 }
11767 Py_INCREF(Py_None); resultobj = Py_None;
11768 return resultobj;
11769 fail:
11770 return NULL;
11771 }
11772
11773
11774 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
11775 PyObject *resultobj;
11776 wxLocale *arg1 = (wxLocale *) 0 ;
11777 wxString *arg2 = 0 ;
11778 wxString const &arg3_defvalue = wxPyEmptyString ;
11779 wxString *arg3 = (wxString *) &arg3_defvalue ;
11780 wxString result;
11781 bool temp2 = false ;
11782 bool temp3 = false ;
11783 PyObject * obj0 = 0 ;
11784 PyObject * obj1 = 0 ;
11785 PyObject * obj2 = 0 ;
11786 char *kwnames[] = {
11787 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
11788 };
11789
11790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
11791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11792 if (SWIG_arg_fail(1)) SWIG_fail;
11793 {
11794 arg2 = wxString_in_helper(obj1);
11795 if (arg2 == NULL) SWIG_fail;
11796 temp2 = true;
11797 }
11798 if (obj2) {
11799 {
11800 arg3 = wxString_in_helper(obj2);
11801 if (arg3 == NULL) SWIG_fail;
11802 temp3 = true;
11803 }
11804 }
11805 {
11806 PyThreadState* __tstate = wxPyBeginAllowThreads();
11807 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
11808
11809 wxPyEndAllowThreads(__tstate);
11810 if (PyErr_Occurred()) SWIG_fail;
11811 }
11812 {
11813 #if wxUSE_UNICODE
11814 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11815 #else
11816 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11817 #endif
11818 }
11819 {
11820 if (temp2)
11821 delete arg2;
11822 }
11823 {
11824 if (temp3)
11825 delete arg3;
11826 }
11827 return resultobj;
11828 fail:
11829 {
11830 if (temp2)
11831 delete arg2;
11832 }
11833 {
11834 if (temp3)
11835 delete arg3;
11836 }
11837 return NULL;
11838 }
11839
11840
11841 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
11842 PyObject *resultobj;
11843 wxLocale *arg1 = (wxLocale *) 0 ;
11844 wxString *result;
11845 PyObject * obj0 = 0 ;
11846 char *kwnames[] = {
11847 (char *) "self", NULL
11848 };
11849
11850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
11851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11852 if (SWIG_arg_fail(1)) SWIG_fail;
11853 {
11854 PyThreadState* __tstate = wxPyBeginAllowThreads();
11855 {
11856 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
11857 result = (wxString *) &_result_ref;
11858 }
11859
11860 wxPyEndAllowThreads(__tstate);
11861 if (PyErr_Occurred()) SWIG_fail;
11862 }
11863 {
11864 #if wxUSE_UNICODE
11865 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11866 #else
11867 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11868 #endif
11869 }
11870 return resultobj;
11871 fail:
11872 return NULL;
11873 }
11874
11875
11876 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
11877 PyObject *obj;
11878 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11879 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
11880 Py_INCREF(obj);
11881 return Py_BuildValue((char *)"");
11882 }
11883 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11884 PyObject *resultobj;
11885 wxLocale *result;
11886 char *kwnames[] = {
11887 NULL
11888 };
11889
11890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
11891 {
11892 PyThreadState* __tstate = wxPyBeginAllowThreads();
11893 result = (wxLocale *)wxGetLocale();
11894
11895 wxPyEndAllowThreads(__tstate);
11896 if (PyErr_Occurred()) SWIG_fail;
11897 }
11898 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
11899 return resultobj;
11900 fail:
11901 return NULL;
11902 }
11903
11904
11905 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
11906 PyObject *resultobj;
11907 wxString *arg1 = 0 ;
11908 wxString result;
11909 bool temp1 = false ;
11910 PyObject * obj0 = 0 ;
11911
11912 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
11913 {
11914 arg1 = wxString_in_helper(obj0);
11915 if (arg1 == NULL) SWIG_fail;
11916 temp1 = true;
11917 }
11918 {
11919 PyThreadState* __tstate = wxPyBeginAllowThreads();
11920 result = wxGetTranslation((wxString const &)*arg1);
11921
11922 wxPyEndAllowThreads(__tstate);
11923 if (PyErr_Occurred()) SWIG_fail;
11924 }
11925 {
11926 #if wxUSE_UNICODE
11927 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11928 #else
11929 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11930 #endif
11931 }
11932 {
11933 if (temp1)
11934 delete arg1;
11935 }
11936 return resultobj;
11937 fail:
11938 {
11939 if (temp1)
11940 delete arg1;
11941 }
11942 return NULL;
11943 }
11944
11945
11946 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
11947 PyObject *resultobj;
11948 wxString *arg1 = 0 ;
11949 wxString *arg2 = 0 ;
11950 size_t arg3 ;
11951 wxString result;
11952 bool temp1 = false ;
11953 bool temp2 = false ;
11954 PyObject * obj0 = 0 ;
11955 PyObject * obj1 = 0 ;
11956 PyObject * obj2 = 0 ;
11957
11958 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
11959 {
11960 arg1 = wxString_in_helper(obj0);
11961 if (arg1 == NULL) SWIG_fail;
11962 temp1 = true;
11963 }
11964 {
11965 arg2 = wxString_in_helper(obj1);
11966 if (arg2 == NULL) SWIG_fail;
11967 temp2 = true;
11968 }
11969 {
11970 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
11971 if (SWIG_arg_fail(3)) SWIG_fail;
11972 }
11973 {
11974 PyThreadState* __tstate = wxPyBeginAllowThreads();
11975 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11976
11977 wxPyEndAllowThreads(__tstate);
11978 if (PyErr_Occurred()) SWIG_fail;
11979 }
11980 {
11981 #if wxUSE_UNICODE
11982 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11983 #else
11984 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11985 #endif
11986 }
11987 {
11988 if (temp1)
11989 delete arg1;
11990 }
11991 {
11992 if (temp2)
11993 delete arg2;
11994 }
11995 return resultobj;
11996 fail:
11997 {
11998 if (temp1)
11999 delete arg1;
12000 }
12001 {
12002 if (temp2)
12003 delete arg2;
12004 }
12005 return NULL;
12006 }
12007
12008
12009 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
12010 int argc;
12011 PyObject *argv[4];
12012 int ii;
12013
12014 argc = PyObject_Length(args);
12015 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
12016 argv[ii] = PyTuple_GetItem(args,ii);
12017 }
12018 if (argc == 1) {
12019 int _v;
12020 {
12021 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12022 }
12023 if (_v) {
12024 return _wrap_GetTranslation__SWIG_0(self,args);
12025 }
12026 }
12027 if (argc == 3) {
12028 int _v;
12029 {
12030 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12031 }
12032 if (_v) {
12033 {
12034 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
12035 }
12036 if (_v) {
12037 _v = SWIG_Check_unsigned_SS_long(argv[2]);
12038 if (_v) {
12039 return _wrap_GetTranslation__SWIG_1(self,args);
12040 }
12041 }
12042 }
12043 }
12044
12045 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
12046 return NULL;
12047 }
12048
12049
12050 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12051 PyObject *resultobj;
12052 wxEncodingConverter *result;
12053 char *kwnames[] = {
12054 NULL
12055 };
12056
12057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
12058 {
12059 PyThreadState* __tstate = wxPyBeginAllowThreads();
12060 result = (wxEncodingConverter *)new wxEncodingConverter();
12061
12062 wxPyEndAllowThreads(__tstate);
12063 if (PyErr_Occurred()) SWIG_fail;
12064 }
12065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
12066 return resultobj;
12067 fail:
12068 return NULL;
12069 }
12070
12071
12072 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12073 PyObject *resultobj;
12074 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12075 PyObject * obj0 = 0 ;
12076 char *kwnames[] = {
12077 (char *) "self", NULL
12078 };
12079
12080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
12081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12082 if (SWIG_arg_fail(1)) SWIG_fail;
12083 {
12084 PyThreadState* __tstate = wxPyBeginAllowThreads();
12085 delete arg1;
12086
12087 wxPyEndAllowThreads(__tstate);
12088 if (PyErr_Occurred()) SWIG_fail;
12089 }
12090 Py_INCREF(Py_None); resultobj = Py_None;
12091 return resultobj;
12092 fail:
12093 return NULL;
12094 }
12095
12096
12097 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
12098 PyObject *resultobj;
12099 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12100 wxFontEncoding arg2 ;
12101 wxFontEncoding arg3 ;
12102 int arg4 = (int) wxCONVERT_STRICT ;
12103 bool result;
12104 PyObject * obj0 = 0 ;
12105 PyObject * obj1 = 0 ;
12106 PyObject * obj2 = 0 ;
12107 PyObject * obj3 = 0 ;
12108 char *kwnames[] = {
12109 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
12110 };
12111
12112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12114 if (SWIG_arg_fail(1)) SWIG_fail;
12115 {
12116 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12117 if (SWIG_arg_fail(2)) SWIG_fail;
12118 }
12119 {
12120 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12121 if (SWIG_arg_fail(3)) SWIG_fail;
12122 }
12123 if (obj3) {
12124 {
12125 arg4 = (int)(SWIG_As_int(obj3));
12126 if (SWIG_arg_fail(4)) SWIG_fail;
12127 }
12128 }
12129 {
12130 PyThreadState* __tstate = wxPyBeginAllowThreads();
12131 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12132
12133 wxPyEndAllowThreads(__tstate);
12134 if (PyErr_Occurred()) SWIG_fail;
12135 }
12136 {
12137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12138 }
12139 return resultobj;
12140 fail:
12141 return NULL;
12142 }
12143
12144
12145 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12146 PyObject *resultobj;
12147 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12148 wxString *arg2 = 0 ;
12149 wxString result;
12150 bool temp2 = false ;
12151 PyObject * obj0 = 0 ;
12152 PyObject * obj1 = 0 ;
12153 char *kwnames[] = {
12154 (char *) "self",(char *) "input", NULL
12155 };
12156
12157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12159 if (SWIG_arg_fail(1)) SWIG_fail;
12160 {
12161 arg2 = wxString_in_helper(obj1);
12162 if (arg2 == NULL) SWIG_fail;
12163 temp2 = true;
12164 }
12165 {
12166 PyThreadState* __tstate = wxPyBeginAllowThreads();
12167 result = (arg1)->Convert((wxString const &)*arg2);
12168
12169 wxPyEndAllowThreads(__tstate);
12170 if (PyErr_Occurred()) SWIG_fail;
12171 }
12172 {
12173 #if wxUSE_UNICODE
12174 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12175 #else
12176 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12177 #endif
12178 }
12179 {
12180 if (temp2)
12181 delete arg2;
12182 }
12183 return resultobj;
12184 fail:
12185 {
12186 if (temp2)
12187 delete arg2;
12188 }
12189 return NULL;
12190 }
12191
12192
12193 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12194 PyObject *resultobj;
12195 wxFontEncoding arg1 ;
12196 int arg2 = (int) wxPLATFORM_CURRENT ;
12197 wxFontEncodingArray result;
12198 PyObject * obj0 = 0 ;
12199 PyObject * obj1 = 0 ;
12200 char *kwnames[] = {
12201 (char *) "enc",(char *) "platform", NULL
12202 };
12203
12204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12205 {
12206 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12207 if (SWIG_arg_fail(1)) SWIG_fail;
12208 }
12209 if (obj1) {
12210 {
12211 arg2 = (int)(SWIG_As_int(obj1));
12212 if (SWIG_arg_fail(2)) SWIG_fail;
12213 }
12214 }
12215 {
12216 PyThreadState* __tstate = wxPyBeginAllowThreads();
12217 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12218
12219 wxPyEndAllowThreads(__tstate);
12220 if (PyErr_Occurred()) SWIG_fail;
12221 }
12222 {
12223 resultobj = PyList_New(0);
12224 for (size_t i=0; i < (&result)->GetCount(); i++) {
12225 PyObject* number = PyInt_FromLong((&result)->Item(i));
12226 PyList_Append(resultobj, number);
12227 Py_DECREF(number);
12228 }
12229 }
12230 return resultobj;
12231 fail:
12232 return NULL;
12233 }
12234
12235
12236 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12237 PyObject *resultobj;
12238 wxFontEncoding arg1 ;
12239 wxFontEncodingArray result;
12240 PyObject * obj0 = 0 ;
12241 char *kwnames[] = {
12242 (char *) "enc", NULL
12243 };
12244
12245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12246 {
12247 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12248 if (SWIG_arg_fail(1)) SWIG_fail;
12249 }
12250 {
12251 PyThreadState* __tstate = wxPyBeginAllowThreads();
12252 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12253
12254 wxPyEndAllowThreads(__tstate);
12255 if (PyErr_Occurred()) SWIG_fail;
12256 }
12257 {
12258 resultobj = PyList_New(0);
12259 for (size_t i=0; i < (&result)->GetCount(); i++) {
12260 PyObject* number = PyInt_FromLong((&result)->Item(i));
12261 PyList_Append(resultobj, number);
12262 Py_DECREF(number);
12263 }
12264 }
12265 return resultobj;
12266 fail:
12267 return NULL;
12268 }
12269
12270
12271 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12272 PyObject *resultobj;
12273 wxFontEncoding arg1 ;
12274 wxFontEncoding arg2 ;
12275 bool result;
12276 PyObject * obj0 = 0 ;
12277 PyObject * obj1 = 0 ;
12278 char *kwnames[] = {
12279 (char *) "encIn",(char *) "encOut", NULL
12280 };
12281
12282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12283 {
12284 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12285 if (SWIG_arg_fail(1)) SWIG_fail;
12286 }
12287 {
12288 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12289 if (SWIG_arg_fail(2)) SWIG_fail;
12290 }
12291 {
12292 PyThreadState* __tstate = wxPyBeginAllowThreads();
12293 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12294
12295 wxPyEndAllowThreads(__tstate);
12296 if (PyErr_Occurred()) SWIG_fail;
12297 }
12298 {
12299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12300 }
12301 return resultobj;
12302 fail:
12303 return NULL;
12304 }
12305
12306
12307 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12308 PyObject *obj;
12309 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12310 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12311 Py_INCREF(obj);
12312 return Py_BuildValue((char *)"");
12313 }
12314 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12315 PyObject *resultobj;
12316 wxDC *arg1 = (wxDC *) 0 ;
12317 PyObject * obj0 = 0 ;
12318 char *kwnames[] = {
12319 (char *) "self", NULL
12320 };
12321
12322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12324 if (SWIG_arg_fail(1)) SWIG_fail;
12325 {
12326 PyThreadState* __tstate = wxPyBeginAllowThreads();
12327 delete arg1;
12328
12329 wxPyEndAllowThreads(__tstate);
12330 if (PyErr_Occurred()) SWIG_fail;
12331 }
12332 Py_INCREF(Py_None); resultobj = Py_None;
12333 return resultobj;
12334 fail:
12335 return NULL;
12336 }
12337
12338
12339 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12340 PyObject *resultobj;
12341 wxDC *arg1 = (wxDC *) 0 ;
12342 PyObject * obj0 = 0 ;
12343 char *kwnames[] = {
12344 (char *) "self", NULL
12345 };
12346
12347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12349 if (SWIG_arg_fail(1)) SWIG_fail;
12350 {
12351 PyThreadState* __tstate = wxPyBeginAllowThreads();
12352 (arg1)->BeginDrawing();
12353
12354 wxPyEndAllowThreads(__tstate);
12355 if (PyErr_Occurred()) SWIG_fail;
12356 }
12357 Py_INCREF(Py_None); resultobj = Py_None;
12358 return resultobj;
12359 fail:
12360 return NULL;
12361 }
12362
12363
12364 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12365 PyObject *resultobj;
12366 wxDC *arg1 = (wxDC *) 0 ;
12367 PyObject * obj0 = 0 ;
12368 char *kwnames[] = {
12369 (char *) "self", NULL
12370 };
12371
12372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12374 if (SWIG_arg_fail(1)) SWIG_fail;
12375 {
12376 PyThreadState* __tstate = wxPyBeginAllowThreads();
12377 (arg1)->EndDrawing();
12378
12379 wxPyEndAllowThreads(__tstate);
12380 if (PyErr_Occurred()) SWIG_fail;
12381 }
12382 Py_INCREF(Py_None); resultobj = Py_None;
12383 return resultobj;
12384 fail:
12385 return NULL;
12386 }
12387
12388
12389 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12390 PyObject *resultobj;
12391 wxDC *arg1 = (wxDC *) 0 ;
12392 int arg2 ;
12393 int arg3 ;
12394 wxColour *arg4 = 0 ;
12395 int arg5 = (int) wxFLOOD_SURFACE ;
12396 bool result;
12397 wxColour temp4 ;
12398 PyObject * obj0 = 0 ;
12399 PyObject * obj1 = 0 ;
12400 PyObject * obj2 = 0 ;
12401 PyObject * obj3 = 0 ;
12402 PyObject * obj4 = 0 ;
12403 char *kwnames[] = {
12404 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12405 };
12406
12407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12409 if (SWIG_arg_fail(1)) SWIG_fail;
12410 {
12411 arg2 = (int)(SWIG_As_int(obj1));
12412 if (SWIG_arg_fail(2)) SWIG_fail;
12413 }
12414 {
12415 arg3 = (int)(SWIG_As_int(obj2));
12416 if (SWIG_arg_fail(3)) SWIG_fail;
12417 }
12418 {
12419 arg4 = &temp4;
12420 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12421 }
12422 if (obj4) {
12423 {
12424 arg5 = (int)(SWIG_As_int(obj4));
12425 if (SWIG_arg_fail(5)) SWIG_fail;
12426 }
12427 }
12428 {
12429 PyThreadState* __tstate = wxPyBeginAllowThreads();
12430 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
12431
12432 wxPyEndAllowThreads(__tstate);
12433 if (PyErr_Occurred()) SWIG_fail;
12434 }
12435 {
12436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12437 }
12438 return resultobj;
12439 fail:
12440 return NULL;
12441 }
12442
12443
12444 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12445 PyObject *resultobj;
12446 wxDC *arg1 = (wxDC *) 0 ;
12447 wxPoint *arg2 = 0 ;
12448 wxColour *arg3 = 0 ;
12449 int arg4 = (int) wxFLOOD_SURFACE ;
12450 bool result;
12451 wxPoint temp2 ;
12452 wxColour temp3 ;
12453 PyObject * obj0 = 0 ;
12454 PyObject * obj1 = 0 ;
12455 PyObject * obj2 = 0 ;
12456 PyObject * obj3 = 0 ;
12457 char *kwnames[] = {
12458 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
12459 };
12460
12461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12463 if (SWIG_arg_fail(1)) SWIG_fail;
12464 {
12465 arg2 = &temp2;
12466 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12467 }
12468 {
12469 arg3 = &temp3;
12470 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
12471 }
12472 if (obj3) {
12473 {
12474 arg4 = (int)(SWIG_As_int(obj3));
12475 if (SWIG_arg_fail(4)) SWIG_fail;
12476 }
12477 }
12478 {
12479 PyThreadState* __tstate = wxPyBeginAllowThreads();
12480 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
12481
12482 wxPyEndAllowThreads(__tstate);
12483 if (PyErr_Occurred()) SWIG_fail;
12484 }
12485 {
12486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12487 }
12488 return resultobj;
12489 fail:
12490 return NULL;
12491 }
12492
12493
12494 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
12495 PyObject *resultobj;
12496 wxDC *arg1 = (wxDC *) 0 ;
12497 int arg2 ;
12498 int arg3 ;
12499 wxColour result;
12500 PyObject * obj0 = 0 ;
12501 PyObject * obj1 = 0 ;
12502 PyObject * obj2 = 0 ;
12503 char *kwnames[] = {
12504 (char *) "self",(char *) "x",(char *) "y", NULL
12505 };
12506
12507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
12508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12509 if (SWIG_arg_fail(1)) SWIG_fail;
12510 {
12511 arg2 = (int)(SWIG_As_int(obj1));
12512 if (SWIG_arg_fail(2)) SWIG_fail;
12513 }
12514 {
12515 arg3 = (int)(SWIG_As_int(obj2));
12516 if (SWIG_arg_fail(3)) SWIG_fail;
12517 }
12518 {
12519 PyThreadState* __tstate = wxPyBeginAllowThreads();
12520 result = wxDC_GetPixel(arg1,arg2,arg3);
12521
12522 wxPyEndAllowThreads(__tstate);
12523 if (PyErr_Occurred()) SWIG_fail;
12524 }
12525 {
12526 wxColour * resultptr;
12527 resultptr = new wxColour((wxColour &)(result));
12528 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12529 }
12530 return resultobj;
12531 fail:
12532 return NULL;
12533 }
12534
12535
12536 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12537 PyObject *resultobj;
12538 wxDC *arg1 = (wxDC *) 0 ;
12539 wxPoint *arg2 = 0 ;
12540 wxColour result;
12541 wxPoint temp2 ;
12542 PyObject * obj0 = 0 ;
12543 PyObject * obj1 = 0 ;
12544 char *kwnames[] = {
12545 (char *) "self",(char *) "pt", NULL
12546 };
12547
12548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
12549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12550 if (SWIG_arg_fail(1)) SWIG_fail;
12551 {
12552 arg2 = &temp2;
12553 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12554 }
12555 {
12556 PyThreadState* __tstate = wxPyBeginAllowThreads();
12557 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
12558
12559 wxPyEndAllowThreads(__tstate);
12560 if (PyErr_Occurred()) SWIG_fail;
12561 }
12562 {
12563 wxColour * resultptr;
12564 resultptr = new wxColour((wxColour &)(result));
12565 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12566 }
12567 return resultobj;
12568 fail:
12569 return NULL;
12570 }
12571
12572
12573 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
12574 PyObject *resultobj;
12575 wxDC *arg1 = (wxDC *) 0 ;
12576 int arg2 ;
12577 int arg3 ;
12578 int arg4 ;
12579 int arg5 ;
12580 PyObject * obj0 = 0 ;
12581 PyObject * obj1 = 0 ;
12582 PyObject * obj2 = 0 ;
12583 PyObject * obj3 = 0 ;
12584 PyObject * obj4 = 0 ;
12585 char *kwnames[] = {
12586 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
12587 };
12588
12589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12591 if (SWIG_arg_fail(1)) SWIG_fail;
12592 {
12593 arg2 = (int)(SWIG_As_int(obj1));
12594 if (SWIG_arg_fail(2)) SWIG_fail;
12595 }
12596 {
12597 arg3 = (int)(SWIG_As_int(obj2));
12598 if (SWIG_arg_fail(3)) SWIG_fail;
12599 }
12600 {
12601 arg4 = (int)(SWIG_As_int(obj3));
12602 if (SWIG_arg_fail(4)) SWIG_fail;
12603 }
12604 {
12605 arg5 = (int)(SWIG_As_int(obj4));
12606 if (SWIG_arg_fail(5)) SWIG_fail;
12607 }
12608 {
12609 PyThreadState* __tstate = wxPyBeginAllowThreads();
12610 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
12611
12612 wxPyEndAllowThreads(__tstate);
12613 if (PyErr_Occurred()) SWIG_fail;
12614 }
12615 Py_INCREF(Py_None); resultobj = Py_None;
12616 return resultobj;
12617 fail:
12618 return NULL;
12619 }
12620
12621
12622 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
12623 PyObject *resultobj;
12624 wxDC *arg1 = (wxDC *) 0 ;
12625 wxPoint *arg2 = 0 ;
12626 wxPoint *arg3 = 0 ;
12627 wxPoint temp2 ;
12628 wxPoint temp3 ;
12629 PyObject * obj0 = 0 ;
12630 PyObject * obj1 = 0 ;
12631 PyObject * obj2 = 0 ;
12632 char *kwnames[] = {
12633 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
12634 };
12635
12636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12638 if (SWIG_arg_fail(1)) SWIG_fail;
12639 {
12640 arg2 = &temp2;
12641 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12642 }
12643 {
12644 arg3 = &temp3;
12645 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12646 }
12647 {
12648 PyThreadState* __tstate = wxPyBeginAllowThreads();
12649 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
12650
12651 wxPyEndAllowThreads(__tstate);
12652 if (PyErr_Occurred()) SWIG_fail;
12653 }
12654 Py_INCREF(Py_None); resultobj = Py_None;
12655 return resultobj;
12656 fail:
12657 return NULL;
12658 }
12659
12660
12661 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
12662 PyObject *resultobj;
12663 wxDC *arg1 = (wxDC *) 0 ;
12664 int arg2 ;
12665 int arg3 ;
12666 PyObject * obj0 = 0 ;
12667 PyObject * obj1 = 0 ;
12668 PyObject * obj2 = 0 ;
12669 char *kwnames[] = {
12670 (char *) "self",(char *) "x",(char *) "y", NULL
12671 };
12672
12673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
12674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12675 if (SWIG_arg_fail(1)) SWIG_fail;
12676 {
12677 arg2 = (int)(SWIG_As_int(obj1));
12678 if (SWIG_arg_fail(2)) SWIG_fail;
12679 }
12680 {
12681 arg3 = (int)(SWIG_As_int(obj2));
12682 if (SWIG_arg_fail(3)) SWIG_fail;
12683 }
12684 {
12685 PyThreadState* __tstate = wxPyBeginAllowThreads();
12686 (arg1)->CrossHair(arg2,arg3);
12687
12688 wxPyEndAllowThreads(__tstate);
12689 if (PyErr_Occurred()) SWIG_fail;
12690 }
12691 Py_INCREF(Py_None); resultobj = Py_None;
12692 return resultobj;
12693 fail:
12694 return NULL;
12695 }
12696
12697
12698 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12699 PyObject *resultobj;
12700 wxDC *arg1 = (wxDC *) 0 ;
12701 wxPoint *arg2 = 0 ;
12702 wxPoint temp2 ;
12703 PyObject * obj0 = 0 ;
12704 PyObject * obj1 = 0 ;
12705 char *kwnames[] = {
12706 (char *) "self",(char *) "pt", NULL
12707 };
12708
12709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
12710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12711 if (SWIG_arg_fail(1)) SWIG_fail;
12712 {
12713 arg2 = &temp2;
12714 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12715 }
12716 {
12717 PyThreadState* __tstate = wxPyBeginAllowThreads();
12718 (arg1)->CrossHair((wxPoint const &)*arg2);
12719
12720 wxPyEndAllowThreads(__tstate);
12721 if (PyErr_Occurred()) SWIG_fail;
12722 }
12723 Py_INCREF(Py_None); resultobj = Py_None;
12724 return resultobj;
12725 fail:
12726 return NULL;
12727 }
12728
12729
12730 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
12731 PyObject *resultobj;
12732 wxDC *arg1 = (wxDC *) 0 ;
12733 int arg2 ;
12734 int arg3 ;
12735 int arg4 ;
12736 int arg5 ;
12737 int arg6 ;
12738 int arg7 ;
12739 PyObject * obj0 = 0 ;
12740 PyObject * obj1 = 0 ;
12741 PyObject * obj2 = 0 ;
12742 PyObject * obj3 = 0 ;
12743 PyObject * obj4 = 0 ;
12744 PyObject * obj5 = 0 ;
12745 PyObject * obj6 = 0 ;
12746 char *kwnames[] = {
12747 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
12748 };
12749
12750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12752 if (SWIG_arg_fail(1)) SWIG_fail;
12753 {
12754 arg2 = (int)(SWIG_As_int(obj1));
12755 if (SWIG_arg_fail(2)) SWIG_fail;
12756 }
12757 {
12758 arg3 = (int)(SWIG_As_int(obj2));
12759 if (SWIG_arg_fail(3)) SWIG_fail;
12760 }
12761 {
12762 arg4 = (int)(SWIG_As_int(obj3));
12763 if (SWIG_arg_fail(4)) SWIG_fail;
12764 }
12765 {
12766 arg5 = (int)(SWIG_As_int(obj4));
12767 if (SWIG_arg_fail(5)) SWIG_fail;
12768 }
12769 {
12770 arg6 = (int)(SWIG_As_int(obj5));
12771 if (SWIG_arg_fail(6)) SWIG_fail;
12772 }
12773 {
12774 arg7 = (int)(SWIG_As_int(obj6));
12775 if (SWIG_arg_fail(7)) SWIG_fail;
12776 }
12777 {
12778 PyThreadState* __tstate = wxPyBeginAllowThreads();
12779 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
12780
12781 wxPyEndAllowThreads(__tstate);
12782 if (PyErr_Occurred()) SWIG_fail;
12783 }
12784 Py_INCREF(Py_None); resultobj = Py_None;
12785 return resultobj;
12786 fail:
12787 return NULL;
12788 }
12789
12790
12791 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12792 PyObject *resultobj;
12793 wxDC *arg1 = (wxDC *) 0 ;
12794 wxPoint *arg2 = 0 ;
12795 wxPoint *arg3 = 0 ;
12796 wxPoint *arg4 = 0 ;
12797 wxPoint temp2 ;
12798 wxPoint temp3 ;
12799 wxPoint temp4 ;
12800 PyObject * obj0 = 0 ;
12801 PyObject * obj1 = 0 ;
12802 PyObject * obj2 = 0 ;
12803 PyObject * obj3 = 0 ;
12804 char *kwnames[] = {
12805 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
12806 };
12807
12808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12810 if (SWIG_arg_fail(1)) SWIG_fail;
12811 {
12812 arg2 = &temp2;
12813 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12814 }
12815 {
12816 arg3 = &temp3;
12817 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12818 }
12819 {
12820 arg4 = &temp4;
12821 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12822 }
12823 {
12824 PyThreadState* __tstate = wxPyBeginAllowThreads();
12825 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
12826
12827 wxPyEndAllowThreads(__tstate);
12828 if (PyErr_Occurred()) SWIG_fail;
12829 }
12830 Py_INCREF(Py_None); resultobj = Py_None;
12831 return resultobj;
12832 fail:
12833 return NULL;
12834 }
12835
12836
12837 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
12838 PyObject *resultobj;
12839 wxDC *arg1 = (wxDC *) 0 ;
12840 int arg2 ;
12841 int arg3 ;
12842 int arg4 ;
12843 int arg5 ;
12844 PyObject * obj0 = 0 ;
12845 PyObject * obj1 = 0 ;
12846 PyObject * obj2 = 0 ;
12847 PyObject * obj3 = 0 ;
12848 PyObject * obj4 = 0 ;
12849 char *kwnames[] = {
12850 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
12851 };
12852
12853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12855 if (SWIG_arg_fail(1)) SWIG_fail;
12856 {
12857 arg2 = (int)(SWIG_As_int(obj1));
12858 if (SWIG_arg_fail(2)) SWIG_fail;
12859 }
12860 {
12861 arg3 = (int)(SWIG_As_int(obj2));
12862 if (SWIG_arg_fail(3)) SWIG_fail;
12863 }
12864 {
12865 arg4 = (int)(SWIG_As_int(obj3));
12866 if (SWIG_arg_fail(4)) SWIG_fail;
12867 }
12868 {
12869 arg5 = (int)(SWIG_As_int(obj4));
12870 if (SWIG_arg_fail(5)) SWIG_fail;
12871 }
12872 {
12873 PyThreadState* __tstate = wxPyBeginAllowThreads();
12874 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
12875
12876 wxPyEndAllowThreads(__tstate);
12877 if (PyErr_Occurred()) SWIG_fail;
12878 }
12879 Py_INCREF(Py_None); resultobj = Py_None;
12880 return resultobj;
12881 fail:
12882 return NULL;
12883 }
12884
12885
12886 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
12887 PyObject *resultobj;
12888 wxDC *arg1 = (wxDC *) 0 ;
12889 wxRect *arg2 = 0 ;
12890 wxRect temp2 ;
12891 PyObject * obj0 = 0 ;
12892 PyObject * obj1 = 0 ;
12893 char *kwnames[] = {
12894 (char *) "self",(char *) "rect", NULL
12895 };
12896
12897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
12898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12899 if (SWIG_arg_fail(1)) SWIG_fail;
12900 {
12901 arg2 = &temp2;
12902 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12903 }
12904 {
12905 PyThreadState* __tstate = wxPyBeginAllowThreads();
12906 (arg1)->DrawCheckMark((wxRect const &)*arg2);
12907
12908 wxPyEndAllowThreads(__tstate);
12909 if (PyErr_Occurred()) SWIG_fail;
12910 }
12911 Py_INCREF(Py_None); resultobj = Py_None;
12912 return resultobj;
12913 fail:
12914 return NULL;
12915 }
12916
12917
12918 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
12919 PyObject *resultobj;
12920 wxDC *arg1 = (wxDC *) 0 ;
12921 int arg2 ;
12922 int arg3 ;
12923 int arg4 ;
12924 int arg5 ;
12925 double arg6 ;
12926 double arg7 ;
12927 PyObject * obj0 = 0 ;
12928 PyObject * obj1 = 0 ;
12929 PyObject * obj2 = 0 ;
12930 PyObject * obj3 = 0 ;
12931 PyObject * obj4 = 0 ;
12932 PyObject * obj5 = 0 ;
12933 PyObject * obj6 = 0 ;
12934 char *kwnames[] = {
12935 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
12936 };
12937
12938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12940 if (SWIG_arg_fail(1)) SWIG_fail;
12941 {
12942 arg2 = (int)(SWIG_As_int(obj1));
12943 if (SWIG_arg_fail(2)) SWIG_fail;
12944 }
12945 {
12946 arg3 = (int)(SWIG_As_int(obj2));
12947 if (SWIG_arg_fail(3)) SWIG_fail;
12948 }
12949 {
12950 arg4 = (int)(SWIG_As_int(obj3));
12951 if (SWIG_arg_fail(4)) SWIG_fail;
12952 }
12953 {
12954 arg5 = (int)(SWIG_As_int(obj4));
12955 if (SWIG_arg_fail(5)) SWIG_fail;
12956 }
12957 {
12958 arg6 = (double)(SWIG_As_double(obj5));
12959 if (SWIG_arg_fail(6)) SWIG_fail;
12960 }
12961 {
12962 arg7 = (double)(SWIG_As_double(obj6));
12963 if (SWIG_arg_fail(7)) SWIG_fail;
12964 }
12965 {
12966 PyThreadState* __tstate = wxPyBeginAllowThreads();
12967 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
12968
12969 wxPyEndAllowThreads(__tstate);
12970 if (PyErr_Occurred()) SWIG_fail;
12971 }
12972 Py_INCREF(Py_None); resultobj = Py_None;
12973 return resultobj;
12974 fail:
12975 return NULL;
12976 }
12977
12978
12979 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
12980 PyObject *resultobj;
12981 wxDC *arg1 = (wxDC *) 0 ;
12982 wxPoint *arg2 = 0 ;
12983 wxSize *arg3 = 0 ;
12984 double arg4 ;
12985 double arg5 ;
12986 wxPoint temp2 ;
12987 wxSize temp3 ;
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 *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
12995 };
12996
12997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",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 = &temp2;
13002 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13003 }
13004 {
13005 arg3 = &temp3;
13006 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13007 }
13008 {
13009 arg4 = (double)(SWIG_As_double(obj3));
13010 if (SWIG_arg_fail(4)) SWIG_fail;
13011 }
13012 {
13013 arg5 = (double)(SWIG_As_double(obj4));
13014 if (SWIG_arg_fail(5)) SWIG_fail;
13015 }
13016 {
13017 PyThreadState* __tstate = wxPyBeginAllowThreads();
13018 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*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_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13031 PyObject *resultobj;
13032 wxDC *arg1 = (wxDC *) 0 ;
13033 int arg2 ;
13034 int arg3 ;
13035 PyObject * obj0 = 0 ;
13036 PyObject * obj1 = 0 ;
13037 PyObject * obj2 = 0 ;
13038 char *kwnames[] = {
13039 (char *) "self",(char *) "x",(char *) "y", NULL
13040 };
13041
13042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13044 if (SWIG_arg_fail(1)) SWIG_fail;
13045 {
13046 arg2 = (int)(SWIG_As_int(obj1));
13047 if (SWIG_arg_fail(2)) SWIG_fail;
13048 }
13049 {
13050 arg3 = (int)(SWIG_As_int(obj2));
13051 if (SWIG_arg_fail(3)) SWIG_fail;
13052 }
13053 {
13054 PyThreadState* __tstate = wxPyBeginAllowThreads();
13055 (arg1)->DrawPoint(arg2,arg3);
13056
13057 wxPyEndAllowThreads(__tstate);
13058 if (PyErr_Occurred()) SWIG_fail;
13059 }
13060 Py_INCREF(Py_None); resultobj = Py_None;
13061 return resultobj;
13062 fail:
13063 return NULL;
13064 }
13065
13066
13067 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13068 PyObject *resultobj;
13069 wxDC *arg1 = (wxDC *) 0 ;
13070 wxPoint *arg2 = 0 ;
13071 wxPoint temp2 ;
13072 PyObject * obj0 = 0 ;
13073 PyObject * obj1 = 0 ;
13074 char *kwnames[] = {
13075 (char *) "self",(char *) "pt", NULL
13076 };
13077
13078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
13079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13080 if (SWIG_arg_fail(1)) SWIG_fail;
13081 {
13082 arg2 = &temp2;
13083 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13084 }
13085 {
13086 PyThreadState* __tstate = wxPyBeginAllowThreads();
13087 (arg1)->DrawPoint((wxPoint const &)*arg2);
13088
13089 wxPyEndAllowThreads(__tstate);
13090 if (PyErr_Occurred()) SWIG_fail;
13091 }
13092 Py_INCREF(Py_None); resultobj = Py_None;
13093 return resultobj;
13094 fail:
13095 return NULL;
13096 }
13097
13098
13099 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13100 PyObject *resultobj;
13101 wxDC *arg1 = (wxDC *) 0 ;
13102 int arg2 ;
13103 int arg3 ;
13104 int arg4 ;
13105 int arg5 ;
13106 PyObject * obj0 = 0 ;
13107 PyObject * obj1 = 0 ;
13108 PyObject * obj2 = 0 ;
13109 PyObject * obj3 = 0 ;
13110 PyObject * obj4 = 0 ;
13111 char *kwnames[] = {
13112 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13113 };
13114
13115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13117 if (SWIG_arg_fail(1)) SWIG_fail;
13118 {
13119 arg2 = (int)(SWIG_As_int(obj1));
13120 if (SWIG_arg_fail(2)) SWIG_fail;
13121 }
13122 {
13123 arg3 = (int)(SWIG_As_int(obj2));
13124 if (SWIG_arg_fail(3)) SWIG_fail;
13125 }
13126 {
13127 arg4 = (int)(SWIG_As_int(obj3));
13128 if (SWIG_arg_fail(4)) SWIG_fail;
13129 }
13130 {
13131 arg5 = (int)(SWIG_As_int(obj4));
13132 if (SWIG_arg_fail(5)) SWIG_fail;
13133 }
13134 {
13135 PyThreadState* __tstate = wxPyBeginAllowThreads();
13136 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13137
13138 wxPyEndAllowThreads(__tstate);
13139 if (PyErr_Occurred()) SWIG_fail;
13140 }
13141 Py_INCREF(Py_None); resultobj = Py_None;
13142 return resultobj;
13143 fail:
13144 return NULL;
13145 }
13146
13147
13148 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13149 PyObject *resultobj;
13150 wxDC *arg1 = (wxDC *) 0 ;
13151 wxRect *arg2 = 0 ;
13152 wxRect temp2 ;
13153 PyObject * obj0 = 0 ;
13154 PyObject * obj1 = 0 ;
13155 char *kwnames[] = {
13156 (char *) "self",(char *) "rect", NULL
13157 };
13158
13159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13161 if (SWIG_arg_fail(1)) SWIG_fail;
13162 {
13163 arg2 = &temp2;
13164 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13165 }
13166 {
13167 PyThreadState* __tstate = wxPyBeginAllowThreads();
13168 (arg1)->DrawRectangle((wxRect const &)*arg2);
13169
13170 wxPyEndAllowThreads(__tstate);
13171 if (PyErr_Occurred()) SWIG_fail;
13172 }
13173 Py_INCREF(Py_None); resultobj = Py_None;
13174 return resultobj;
13175 fail:
13176 return NULL;
13177 }
13178
13179
13180 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13181 PyObject *resultobj;
13182 wxDC *arg1 = (wxDC *) 0 ;
13183 wxPoint *arg2 = 0 ;
13184 wxSize *arg3 = 0 ;
13185 wxPoint temp2 ;
13186 wxSize temp3 ;
13187 PyObject * obj0 = 0 ;
13188 PyObject * obj1 = 0 ;
13189 PyObject * obj2 = 0 ;
13190 char *kwnames[] = {
13191 (char *) "self",(char *) "pt",(char *) "sz", NULL
13192 };
13193
13194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13196 if (SWIG_arg_fail(1)) SWIG_fail;
13197 {
13198 arg2 = &temp2;
13199 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13200 }
13201 {
13202 arg3 = &temp3;
13203 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13204 }
13205 {
13206 PyThreadState* __tstate = wxPyBeginAllowThreads();
13207 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13208
13209 wxPyEndAllowThreads(__tstate);
13210 if (PyErr_Occurred()) SWIG_fail;
13211 }
13212 Py_INCREF(Py_None); resultobj = Py_None;
13213 return resultobj;
13214 fail:
13215 return NULL;
13216 }
13217
13218
13219 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13220 PyObject *resultobj;
13221 wxDC *arg1 = (wxDC *) 0 ;
13222 int arg2 ;
13223 int arg3 ;
13224 int arg4 ;
13225 int arg5 ;
13226 double arg6 ;
13227 PyObject * obj0 = 0 ;
13228 PyObject * obj1 = 0 ;
13229 PyObject * obj2 = 0 ;
13230 PyObject * obj3 = 0 ;
13231 PyObject * obj4 = 0 ;
13232 PyObject * obj5 = 0 ;
13233 char *kwnames[] = {
13234 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13235 };
13236
13237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13239 if (SWIG_arg_fail(1)) SWIG_fail;
13240 {
13241 arg2 = (int)(SWIG_As_int(obj1));
13242 if (SWIG_arg_fail(2)) SWIG_fail;
13243 }
13244 {
13245 arg3 = (int)(SWIG_As_int(obj2));
13246 if (SWIG_arg_fail(3)) SWIG_fail;
13247 }
13248 {
13249 arg4 = (int)(SWIG_As_int(obj3));
13250 if (SWIG_arg_fail(4)) SWIG_fail;
13251 }
13252 {
13253 arg5 = (int)(SWIG_As_int(obj4));
13254 if (SWIG_arg_fail(5)) SWIG_fail;
13255 }
13256 {
13257 arg6 = (double)(SWIG_As_double(obj5));
13258 if (SWIG_arg_fail(6)) SWIG_fail;
13259 }
13260 {
13261 PyThreadState* __tstate = wxPyBeginAllowThreads();
13262 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13263
13264 wxPyEndAllowThreads(__tstate);
13265 if (PyErr_Occurred()) SWIG_fail;
13266 }
13267 Py_INCREF(Py_None); resultobj = Py_None;
13268 return resultobj;
13269 fail:
13270 return NULL;
13271 }
13272
13273
13274 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13275 PyObject *resultobj;
13276 wxDC *arg1 = (wxDC *) 0 ;
13277 wxRect *arg2 = 0 ;
13278 double arg3 ;
13279 wxRect temp2 ;
13280 PyObject * obj0 = 0 ;
13281 PyObject * obj1 = 0 ;
13282 PyObject * obj2 = 0 ;
13283 char *kwnames[] = {
13284 (char *) "self",(char *) "r",(char *) "radius", NULL
13285 };
13286
13287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13289 if (SWIG_arg_fail(1)) SWIG_fail;
13290 {
13291 arg2 = &temp2;
13292 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13293 }
13294 {
13295 arg3 = (double)(SWIG_As_double(obj2));
13296 if (SWIG_arg_fail(3)) SWIG_fail;
13297 }
13298 {
13299 PyThreadState* __tstate = wxPyBeginAllowThreads();
13300 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13301
13302 wxPyEndAllowThreads(__tstate);
13303 if (PyErr_Occurred()) SWIG_fail;
13304 }
13305 Py_INCREF(Py_None); resultobj = Py_None;
13306 return resultobj;
13307 fail:
13308 return NULL;
13309 }
13310
13311
13312 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13313 PyObject *resultobj;
13314 wxDC *arg1 = (wxDC *) 0 ;
13315 wxPoint *arg2 = 0 ;
13316 wxSize *arg3 = 0 ;
13317 double arg4 ;
13318 wxPoint temp2 ;
13319 wxSize temp3 ;
13320 PyObject * obj0 = 0 ;
13321 PyObject * obj1 = 0 ;
13322 PyObject * obj2 = 0 ;
13323 PyObject * obj3 = 0 ;
13324 char *kwnames[] = {
13325 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13326 };
13327
13328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13330 if (SWIG_arg_fail(1)) SWIG_fail;
13331 {
13332 arg2 = &temp2;
13333 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13334 }
13335 {
13336 arg3 = &temp3;
13337 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13338 }
13339 {
13340 arg4 = (double)(SWIG_As_double(obj3));
13341 if (SWIG_arg_fail(4)) SWIG_fail;
13342 }
13343 {
13344 PyThreadState* __tstate = wxPyBeginAllowThreads();
13345 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13346
13347 wxPyEndAllowThreads(__tstate);
13348 if (PyErr_Occurred()) SWIG_fail;
13349 }
13350 Py_INCREF(Py_None); resultobj = Py_None;
13351 return resultobj;
13352 fail:
13353 return NULL;
13354 }
13355
13356
13357 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13358 PyObject *resultobj;
13359 wxDC *arg1 = (wxDC *) 0 ;
13360 int arg2 ;
13361 int arg3 ;
13362 int arg4 ;
13363 PyObject * obj0 = 0 ;
13364 PyObject * obj1 = 0 ;
13365 PyObject * obj2 = 0 ;
13366 PyObject * obj3 = 0 ;
13367 char *kwnames[] = {
13368 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13369 };
13370
13371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13373 if (SWIG_arg_fail(1)) SWIG_fail;
13374 {
13375 arg2 = (int)(SWIG_As_int(obj1));
13376 if (SWIG_arg_fail(2)) SWIG_fail;
13377 }
13378 {
13379 arg3 = (int)(SWIG_As_int(obj2));
13380 if (SWIG_arg_fail(3)) SWIG_fail;
13381 }
13382 {
13383 arg4 = (int)(SWIG_As_int(obj3));
13384 if (SWIG_arg_fail(4)) SWIG_fail;
13385 }
13386 {
13387 PyThreadState* __tstate = wxPyBeginAllowThreads();
13388 (arg1)->DrawCircle(arg2,arg3,arg4);
13389
13390 wxPyEndAllowThreads(__tstate);
13391 if (PyErr_Occurred()) SWIG_fail;
13392 }
13393 Py_INCREF(Py_None); resultobj = Py_None;
13394 return resultobj;
13395 fail:
13396 return NULL;
13397 }
13398
13399
13400 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13401 PyObject *resultobj;
13402 wxDC *arg1 = (wxDC *) 0 ;
13403 wxPoint *arg2 = 0 ;
13404 int arg3 ;
13405 wxPoint temp2 ;
13406 PyObject * obj0 = 0 ;
13407 PyObject * obj1 = 0 ;
13408 PyObject * obj2 = 0 ;
13409 char *kwnames[] = {
13410 (char *) "self",(char *) "pt",(char *) "radius", NULL
13411 };
13412
13413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13415 if (SWIG_arg_fail(1)) SWIG_fail;
13416 {
13417 arg2 = &temp2;
13418 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13419 }
13420 {
13421 arg3 = (int)(SWIG_As_int(obj2));
13422 if (SWIG_arg_fail(3)) SWIG_fail;
13423 }
13424 {
13425 PyThreadState* __tstate = wxPyBeginAllowThreads();
13426 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13427
13428 wxPyEndAllowThreads(__tstate);
13429 if (PyErr_Occurred()) SWIG_fail;
13430 }
13431 Py_INCREF(Py_None); resultobj = Py_None;
13432 return resultobj;
13433 fail:
13434 return NULL;
13435 }
13436
13437
13438 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
13439 PyObject *resultobj;
13440 wxDC *arg1 = (wxDC *) 0 ;
13441 int arg2 ;
13442 int arg3 ;
13443 int arg4 ;
13444 int arg5 ;
13445 PyObject * obj0 = 0 ;
13446 PyObject * obj1 = 0 ;
13447 PyObject * obj2 = 0 ;
13448 PyObject * obj3 = 0 ;
13449 PyObject * obj4 = 0 ;
13450 char *kwnames[] = {
13451 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13452 };
13453
13454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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 arg2 = (int)(SWIG_As_int(obj1));
13459 if (SWIG_arg_fail(2)) SWIG_fail;
13460 }
13461 {
13462 arg3 = (int)(SWIG_As_int(obj2));
13463 if (SWIG_arg_fail(3)) SWIG_fail;
13464 }
13465 {
13466 arg4 = (int)(SWIG_As_int(obj3));
13467 if (SWIG_arg_fail(4)) SWIG_fail;
13468 }
13469 {
13470 arg5 = (int)(SWIG_As_int(obj4));
13471 if (SWIG_arg_fail(5)) SWIG_fail;
13472 }
13473 {
13474 PyThreadState* __tstate = wxPyBeginAllowThreads();
13475 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
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_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
13488 PyObject *resultobj;
13489 wxDC *arg1 = (wxDC *) 0 ;
13490 wxRect *arg2 = 0 ;
13491 wxRect temp2 ;
13492 PyObject * obj0 = 0 ;
13493 PyObject * obj1 = 0 ;
13494 char *kwnames[] = {
13495 (char *) "self",(char *) "rect", NULL
13496 };
13497
13498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
13499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13500 if (SWIG_arg_fail(1)) SWIG_fail;
13501 {
13502 arg2 = &temp2;
13503 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13504 }
13505 {
13506 PyThreadState* __tstate = wxPyBeginAllowThreads();
13507 (arg1)->DrawEllipse((wxRect const &)*arg2);
13508
13509 wxPyEndAllowThreads(__tstate);
13510 if (PyErr_Occurred()) SWIG_fail;
13511 }
13512 Py_INCREF(Py_None); resultobj = Py_None;
13513 return resultobj;
13514 fail:
13515 return NULL;
13516 }
13517
13518
13519 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13520 PyObject *resultobj;
13521 wxDC *arg1 = (wxDC *) 0 ;
13522 wxPoint *arg2 = 0 ;
13523 wxSize *arg3 = 0 ;
13524 wxPoint temp2 ;
13525 wxSize temp3 ;
13526 PyObject * obj0 = 0 ;
13527 PyObject * obj1 = 0 ;
13528 PyObject * obj2 = 0 ;
13529 char *kwnames[] = {
13530 (char *) "self",(char *) "pt",(char *) "sz", NULL
13531 };
13532
13533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13535 if (SWIG_arg_fail(1)) SWIG_fail;
13536 {
13537 arg2 = &temp2;
13538 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13539 }
13540 {
13541 arg3 = &temp3;
13542 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13543 }
13544 {
13545 PyThreadState* __tstate = wxPyBeginAllowThreads();
13546 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
13547
13548 wxPyEndAllowThreads(__tstate);
13549 if (PyErr_Occurred()) SWIG_fail;
13550 }
13551 Py_INCREF(Py_None); resultobj = Py_None;
13552 return resultobj;
13553 fail:
13554 return NULL;
13555 }
13556
13557
13558 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13559 PyObject *resultobj;
13560 wxDC *arg1 = (wxDC *) 0 ;
13561 wxIcon *arg2 = 0 ;
13562 int arg3 ;
13563 int arg4 ;
13564 PyObject * obj0 = 0 ;
13565 PyObject * obj1 = 0 ;
13566 PyObject * obj2 = 0 ;
13567 PyObject * obj3 = 0 ;
13568 char *kwnames[] = {
13569 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
13570 };
13571
13572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13574 if (SWIG_arg_fail(1)) SWIG_fail;
13575 {
13576 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13577 if (SWIG_arg_fail(2)) SWIG_fail;
13578 if (arg2 == NULL) {
13579 SWIG_null_ref("wxIcon");
13580 }
13581 if (SWIG_arg_fail(2)) SWIG_fail;
13582 }
13583 {
13584 arg3 = (int)(SWIG_As_int(obj2));
13585 if (SWIG_arg_fail(3)) SWIG_fail;
13586 }
13587 {
13588 arg4 = (int)(SWIG_As_int(obj3));
13589 if (SWIG_arg_fail(4)) SWIG_fail;
13590 }
13591 {
13592 PyThreadState* __tstate = wxPyBeginAllowThreads();
13593 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
13594
13595 wxPyEndAllowThreads(__tstate);
13596 if (PyErr_Occurred()) SWIG_fail;
13597 }
13598 Py_INCREF(Py_None); resultobj = Py_None;
13599 return resultobj;
13600 fail:
13601 return NULL;
13602 }
13603
13604
13605 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13606 PyObject *resultobj;
13607 wxDC *arg1 = (wxDC *) 0 ;
13608 wxIcon *arg2 = 0 ;
13609 wxPoint *arg3 = 0 ;
13610 wxPoint temp3 ;
13611 PyObject * obj0 = 0 ;
13612 PyObject * obj1 = 0 ;
13613 PyObject * obj2 = 0 ;
13614 char *kwnames[] = {
13615 (char *) "self",(char *) "icon",(char *) "pt", NULL
13616 };
13617
13618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13620 if (SWIG_arg_fail(1)) SWIG_fail;
13621 {
13622 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13623 if (SWIG_arg_fail(2)) SWIG_fail;
13624 if (arg2 == NULL) {
13625 SWIG_null_ref("wxIcon");
13626 }
13627 if (SWIG_arg_fail(2)) SWIG_fail;
13628 }
13629 {
13630 arg3 = &temp3;
13631 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13632 }
13633 {
13634 PyThreadState* __tstate = wxPyBeginAllowThreads();
13635 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
13636
13637 wxPyEndAllowThreads(__tstate);
13638 if (PyErr_Occurred()) SWIG_fail;
13639 }
13640 Py_INCREF(Py_None); resultobj = Py_None;
13641 return resultobj;
13642 fail:
13643 return NULL;
13644 }
13645
13646
13647 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13648 PyObject *resultobj;
13649 wxDC *arg1 = (wxDC *) 0 ;
13650 wxBitmap *arg2 = 0 ;
13651 int arg3 ;
13652 int arg4 ;
13653 bool arg5 = (bool) false ;
13654 PyObject * obj0 = 0 ;
13655 PyObject * obj1 = 0 ;
13656 PyObject * obj2 = 0 ;
13657 PyObject * obj3 = 0 ;
13658 PyObject * obj4 = 0 ;
13659 char *kwnames[] = {
13660 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
13661 };
13662
13663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13665 if (SWIG_arg_fail(1)) SWIG_fail;
13666 {
13667 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13668 if (SWIG_arg_fail(2)) SWIG_fail;
13669 if (arg2 == NULL) {
13670 SWIG_null_ref("wxBitmap");
13671 }
13672 if (SWIG_arg_fail(2)) SWIG_fail;
13673 }
13674 {
13675 arg3 = (int)(SWIG_As_int(obj2));
13676 if (SWIG_arg_fail(3)) SWIG_fail;
13677 }
13678 {
13679 arg4 = (int)(SWIG_As_int(obj3));
13680 if (SWIG_arg_fail(4)) SWIG_fail;
13681 }
13682 if (obj4) {
13683 {
13684 arg5 = (bool)(SWIG_As_bool(obj4));
13685 if (SWIG_arg_fail(5)) SWIG_fail;
13686 }
13687 }
13688 {
13689 PyThreadState* __tstate = wxPyBeginAllowThreads();
13690 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
13691
13692 wxPyEndAllowThreads(__tstate);
13693 if (PyErr_Occurred()) SWIG_fail;
13694 }
13695 Py_INCREF(Py_None); resultobj = Py_None;
13696 return resultobj;
13697 fail:
13698 return NULL;
13699 }
13700
13701
13702 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13703 PyObject *resultobj;
13704 wxDC *arg1 = (wxDC *) 0 ;
13705 wxBitmap *arg2 = 0 ;
13706 wxPoint *arg3 = 0 ;
13707 bool arg4 = (bool) false ;
13708 wxPoint temp3 ;
13709 PyObject * obj0 = 0 ;
13710 PyObject * obj1 = 0 ;
13711 PyObject * obj2 = 0 ;
13712 PyObject * obj3 = 0 ;
13713 char *kwnames[] = {
13714 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
13715 };
13716
13717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13719 if (SWIG_arg_fail(1)) SWIG_fail;
13720 {
13721 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13722 if (SWIG_arg_fail(2)) SWIG_fail;
13723 if (arg2 == NULL) {
13724 SWIG_null_ref("wxBitmap");
13725 }
13726 if (SWIG_arg_fail(2)) SWIG_fail;
13727 }
13728 {
13729 arg3 = &temp3;
13730 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13731 }
13732 if (obj3) {
13733 {
13734 arg4 = (bool)(SWIG_As_bool(obj3));
13735 if (SWIG_arg_fail(4)) SWIG_fail;
13736 }
13737 }
13738 {
13739 PyThreadState* __tstate = wxPyBeginAllowThreads();
13740 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
13741
13742 wxPyEndAllowThreads(__tstate);
13743 if (PyErr_Occurred()) SWIG_fail;
13744 }
13745 Py_INCREF(Py_None); resultobj = Py_None;
13746 return resultobj;
13747 fail:
13748 return NULL;
13749 }
13750
13751
13752 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
13753 PyObject *resultobj;
13754 wxDC *arg1 = (wxDC *) 0 ;
13755 wxString *arg2 = 0 ;
13756 int arg3 ;
13757 int arg4 ;
13758 bool temp2 = false ;
13759 PyObject * obj0 = 0 ;
13760 PyObject * obj1 = 0 ;
13761 PyObject * obj2 = 0 ;
13762 PyObject * obj3 = 0 ;
13763 char *kwnames[] = {
13764 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
13765 };
13766
13767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13769 if (SWIG_arg_fail(1)) SWIG_fail;
13770 {
13771 arg2 = wxString_in_helper(obj1);
13772 if (arg2 == NULL) SWIG_fail;
13773 temp2 = true;
13774 }
13775 {
13776 arg3 = (int)(SWIG_As_int(obj2));
13777 if (SWIG_arg_fail(3)) SWIG_fail;
13778 }
13779 {
13780 arg4 = (int)(SWIG_As_int(obj3));
13781 if (SWIG_arg_fail(4)) SWIG_fail;
13782 }
13783 {
13784 PyThreadState* __tstate = wxPyBeginAllowThreads();
13785 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
13786
13787 wxPyEndAllowThreads(__tstate);
13788 if (PyErr_Occurred()) SWIG_fail;
13789 }
13790 Py_INCREF(Py_None); resultobj = Py_None;
13791 {
13792 if (temp2)
13793 delete arg2;
13794 }
13795 return resultobj;
13796 fail:
13797 {
13798 if (temp2)
13799 delete arg2;
13800 }
13801 return NULL;
13802 }
13803
13804
13805 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13806 PyObject *resultobj;
13807 wxDC *arg1 = (wxDC *) 0 ;
13808 wxString *arg2 = 0 ;
13809 wxPoint *arg3 = 0 ;
13810 bool temp2 = false ;
13811 wxPoint temp3 ;
13812 PyObject * obj0 = 0 ;
13813 PyObject * obj1 = 0 ;
13814 PyObject * obj2 = 0 ;
13815 char *kwnames[] = {
13816 (char *) "self",(char *) "text",(char *) "pt", NULL
13817 };
13818
13819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13821 if (SWIG_arg_fail(1)) SWIG_fail;
13822 {
13823 arg2 = wxString_in_helper(obj1);
13824 if (arg2 == NULL) SWIG_fail;
13825 temp2 = true;
13826 }
13827 {
13828 arg3 = &temp3;
13829 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13830 }
13831 {
13832 PyThreadState* __tstate = wxPyBeginAllowThreads();
13833 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
13834
13835 wxPyEndAllowThreads(__tstate);
13836 if (PyErr_Occurred()) SWIG_fail;
13837 }
13838 Py_INCREF(Py_None); resultobj = Py_None;
13839 {
13840 if (temp2)
13841 delete arg2;
13842 }
13843 return resultobj;
13844 fail:
13845 {
13846 if (temp2)
13847 delete arg2;
13848 }
13849 return NULL;
13850 }
13851
13852
13853 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
13854 PyObject *resultobj;
13855 wxDC *arg1 = (wxDC *) 0 ;
13856 wxString *arg2 = 0 ;
13857 int arg3 ;
13858 int arg4 ;
13859 double arg5 ;
13860 bool temp2 = false ;
13861 PyObject * obj0 = 0 ;
13862 PyObject * obj1 = 0 ;
13863 PyObject * obj2 = 0 ;
13864 PyObject * obj3 = 0 ;
13865 PyObject * obj4 = 0 ;
13866 char *kwnames[] = {
13867 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
13868 };
13869
13870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13872 if (SWIG_arg_fail(1)) SWIG_fail;
13873 {
13874 arg2 = wxString_in_helper(obj1);
13875 if (arg2 == NULL) SWIG_fail;
13876 temp2 = true;
13877 }
13878 {
13879 arg3 = (int)(SWIG_As_int(obj2));
13880 if (SWIG_arg_fail(3)) SWIG_fail;
13881 }
13882 {
13883 arg4 = (int)(SWIG_As_int(obj3));
13884 if (SWIG_arg_fail(4)) SWIG_fail;
13885 }
13886 {
13887 arg5 = (double)(SWIG_As_double(obj4));
13888 if (SWIG_arg_fail(5)) SWIG_fail;
13889 }
13890 {
13891 PyThreadState* __tstate = wxPyBeginAllowThreads();
13892 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
13893
13894 wxPyEndAllowThreads(__tstate);
13895 if (PyErr_Occurred()) SWIG_fail;
13896 }
13897 Py_INCREF(Py_None); resultobj = Py_None;
13898 {
13899 if (temp2)
13900 delete arg2;
13901 }
13902 return resultobj;
13903 fail:
13904 {
13905 if (temp2)
13906 delete arg2;
13907 }
13908 return NULL;
13909 }
13910
13911
13912 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13913 PyObject *resultobj;
13914 wxDC *arg1 = (wxDC *) 0 ;
13915 wxString *arg2 = 0 ;
13916 wxPoint *arg3 = 0 ;
13917 double arg4 ;
13918 bool temp2 = false ;
13919 wxPoint temp3 ;
13920 PyObject * obj0 = 0 ;
13921 PyObject * obj1 = 0 ;
13922 PyObject * obj2 = 0 ;
13923 PyObject * obj3 = 0 ;
13924 char *kwnames[] = {
13925 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
13926 };
13927
13928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13930 if (SWIG_arg_fail(1)) SWIG_fail;
13931 {
13932 arg2 = wxString_in_helper(obj1);
13933 if (arg2 == NULL) SWIG_fail;
13934 temp2 = true;
13935 }
13936 {
13937 arg3 = &temp3;
13938 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13939 }
13940 {
13941 arg4 = (double)(SWIG_As_double(obj3));
13942 if (SWIG_arg_fail(4)) SWIG_fail;
13943 }
13944 {
13945 PyThreadState* __tstate = wxPyBeginAllowThreads();
13946 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
13947
13948 wxPyEndAllowThreads(__tstate);
13949 if (PyErr_Occurred()) SWIG_fail;
13950 }
13951 Py_INCREF(Py_None); resultobj = Py_None;
13952 {
13953 if (temp2)
13954 delete arg2;
13955 }
13956 return resultobj;
13957 fail:
13958 {
13959 if (temp2)
13960 delete arg2;
13961 }
13962 return NULL;
13963 }
13964
13965
13966 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
13967 PyObject *resultobj;
13968 wxDC *arg1 = (wxDC *) 0 ;
13969 int arg2 ;
13970 int arg3 ;
13971 int arg4 ;
13972 int arg5 ;
13973 wxDC *arg6 = (wxDC *) 0 ;
13974 int arg7 ;
13975 int arg8 ;
13976 int arg9 = (int) wxCOPY ;
13977 bool arg10 = (bool) false ;
13978 int arg11 = (int) -1 ;
13979 int arg12 = (int) -1 ;
13980 bool result;
13981 PyObject * obj0 = 0 ;
13982 PyObject * obj1 = 0 ;
13983 PyObject * obj2 = 0 ;
13984 PyObject * obj3 = 0 ;
13985 PyObject * obj4 = 0 ;
13986 PyObject * obj5 = 0 ;
13987 PyObject * obj6 = 0 ;
13988 PyObject * obj7 = 0 ;
13989 PyObject * obj8 = 0 ;
13990 PyObject * obj9 = 0 ;
13991 PyObject * obj10 = 0 ;
13992 PyObject * obj11 = 0 ;
13993 char *kwnames[] = {
13994 (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
13995 };
13996
13997 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;
13998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13999 if (SWIG_arg_fail(1)) SWIG_fail;
14000 {
14001 arg2 = (int)(SWIG_As_int(obj1));
14002 if (SWIG_arg_fail(2)) SWIG_fail;
14003 }
14004 {
14005 arg3 = (int)(SWIG_As_int(obj2));
14006 if (SWIG_arg_fail(3)) SWIG_fail;
14007 }
14008 {
14009 arg4 = (int)(SWIG_As_int(obj3));
14010 if (SWIG_arg_fail(4)) SWIG_fail;
14011 }
14012 {
14013 arg5 = (int)(SWIG_As_int(obj4));
14014 if (SWIG_arg_fail(5)) SWIG_fail;
14015 }
14016 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14017 if (SWIG_arg_fail(6)) SWIG_fail;
14018 {
14019 arg7 = (int)(SWIG_As_int(obj6));
14020 if (SWIG_arg_fail(7)) SWIG_fail;
14021 }
14022 {
14023 arg8 = (int)(SWIG_As_int(obj7));
14024 if (SWIG_arg_fail(8)) SWIG_fail;
14025 }
14026 if (obj8) {
14027 {
14028 arg9 = (int)(SWIG_As_int(obj8));
14029 if (SWIG_arg_fail(9)) SWIG_fail;
14030 }
14031 }
14032 if (obj9) {
14033 {
14034 arg10 = (bool)(SWIG_As_bool(obj9));
14035 if (SWIG_arg_fail(10)) SWIG_fail;
14036 }
14037 }
14038 if (obj10) {
14039 {
14040 arg11 = (int)(SWIG_As_int(obj10));
14041 if (SWIG_arg_fail(11)) SWIG_fail;
14042 }
14043 }
14044 if (obj11) {
14045 {
14046 arg12 = (int)(SWIG_As_int(obj11));
14047 if (SWIG_arg_fail(12)) SWIG_fail;
14048 }
14049 }
14050 {
14051 PyThreadState* __tstate = wxPyBeginAllowThreads();
14052 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14053
14054 wxPyEndAllowThreads(__tstate);
14055 if (PyErr_Occurred()) SWIG_fail;
14056 }
14057 {
14058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14059 }
14060 return resultobj;
14061 fail:
14062 return NULL;
14063 }
14064
14065
14066 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14067 PyObject *resultobj;
14068 wxDC *arg1 = (wxDC *) 0 ;
14069 wxPoint *arg2 = 0 ;
14070 wxSize *arg3 = 0 ;
14071 wxDC *arg4 = (wxDC *) 0 ;
14072 wxPoint *arg5 = 0 ;
14073 int arg6 = (int) wxCOPY ;
14074 bool arg7 = (bool) false ;
14075 wxPoint const &arg8_defvalue = wxDefaultPosition ;
14076 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
14077 bool result;
14078 wxPoint temp2 ;
14079 wxSize temp3 ;
14080 wxPoint temp5 ;
14081 wxPoint temp8 ;
14082 PyObject * obj0 = 0 ;
14083 PyObject * obj1 = 0 ;
14084 PyObject * obj2 = 0 ;
14085 PyObject * obj3 = 0 ;
14086 PyObject * obj4 = 0 ;
14087 PyObject * obj5 = 0 ;
14088 PyObject * obj6 = 0 ;
14089 PyObject * obj7 = 0 ;
14090 char *kwnames[] = {
14091 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
14092 };
14093
14094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
14095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14096 if (SWIG_arg_fail(1)) SWIG_fail;
14097 {
14098 arg2 = &temp2;
14099 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14100 }
14101 {
14102 arg3 = &temp3;
14103 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14104 }
14105 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14106 if (SWIG_arg_fail(4)) SWIG_fail;
14107 {
14108 arg5 = &temp5;
14109 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14110 }
14111 if (obj5) {
14112 {
14113 arg6 = (int)(SWIG_As_int(obj5));
14114 if (SWIG_arg_fail(6)) SWIG_fail;
14115 }
14116 }
14117 if (obj6) {
14118 {
14119 arg7 = (bool)(SWIG_As_bool(obj6));
14120 if (SWIG_arg_fail(7)) SWIG_fail;
14121 }
14122 }
14123 if (obj7) {
14124 {
14125 arg8 = &temp8;
14126 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14127 }
14128 }
14129 {
14130 PyThreadState* __tstate = wxPyBeginAllowThreads();
14131 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14132
14133 wxPyEndAllowThreads(__tstate);
14134 if (PyErr_Occurred()) SWIG_fail;
14135 }
14136 {
14137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14138 }
14139 return resultobj;
14140 fail:
14141 return NULL;
14142 }
14143
14144
14145 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14146 PyObject *resultobj;
14147 wxDC *arg1 = (wxDC *) 0 ;
14148 int arg2 ;
14149 int arg3 ;
14150 int arg4 ;
14151 int arg5 ;
14152 PyObject * obj0 = 0 ;
14153 PyObject * obj1 = 0 ;
14154 PyObject * obj2 = 0 ;
14155 PyObject * obj3 = 0 ;
14156 PyObject * obj4 = 0 ;
14157 char *kwnames[] = {
14158 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14159 };
14160
14161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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 = (int)(SWIG_As_int(obj1));
14166 if (SWIG_arg_fail(2)) SWIG_fail;
14167 }
14168 {
14169 arg3 = (int)(SWIG_As_int(obj2));
14170 if (SWIG_arg_fail(3)) SWIG_fail;
14171 }
14172 {
14173 arg4 = (int)(SWIG_As_int(obj3));
14174 if (SWIG_arg_fail(4)) SWIG_fail;
14175 }
14176 {
14177 arg5 = (int)(SWIG_As_int(obj4));
14178 if (SWIG_arg_fail(5)) SWIG_fail;
14179 }
14180 {
14181 PyThreadState* __tstate = wxPyBeginAllowThreads();
14182 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14183
14184 wxPyEndAllowThreads(__tstate);
14185 if (PyErr_Occurred()) SWIG_fail;
14186 }
14187 Py_INCREF(Py_None); resultobj = Py_None;
14188 return resultobj;
14189 fail:
14190 return NULL;
14191 }
14192
14193
14194 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14195 PyObject *resultobj;
14196 wxDC *arg1 = (wxDC *) 0 ;
14197 wxPoint *arg2 = 0 ;
14198 wxSize *arg3 = 0 ;
14199 wxPoint temp2 ;
14200 wxSize temp3 ;
14201 PyObject * obj0 = 0 ;
14202 PyObject * obj1 = 0 ;
14203 PyObject * obj2 = 0 ;
14204 char *kwnames[] = {
14205 (char *) "self",(char *) "pt",(char *) "sz", NULL
14206 };
14207
14208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14210 if (SWIG_arg_fail(1)) SWIG_fail;
14211 {
14212 arg2 = &temp2;
14213 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14214 }
14215 {
14216 arg3 = &temp3;
14217 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14218 }
14219 {
14220 PyThreadState* __tstate = wxPyBeginAllowThreads();
14221 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14222
14223 wxPyEndAllowThreads(__tstate);
14224 if (PyErr_Occurred()) SWIG_fail;
14225 }
14226 Py_INCREF(Py_None); resultobj = Py_None;
14227 return resultobj;
14228 fail:
14229 return NULL;
14230 }
14231
14232
14233 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14234 PyObject *resultobj;
14235 wxDC *arg1 = (wxDC *) 0 ;
14236 wxRegion *arg2 = 0 ;
14237 PyObject * obj0 = 0 ;
14238 PyObject * obj1 = 0 ;
14239 char *kwnames[] = {
14240 (char *) "self",(char *) "region", NULL
14241 };
14242
14243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14245 if (SWIG_arg_fail(1)) SWIG_fail;
14246 {
14247 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14248 if (SWIG_arg_fail(2)) SWIG_fail;
14249 if (arg2 == NULL) {
14250 SWIG_null_ref("wxRegion");
14251 }
14252 if (SWIG_arg_fail(2)) SWIG_fail;
14253 }
14254 {
14255 PyThreadState* __tstate = wxPyBeginAllowThreads();
14256 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14257
14258 wxPyEndAllowThreads(__tstate);
14259 if (PyErr_Occurred()) SWIG_fail;
14260 }
14261 Py_INCREF(Py_None); resultobj = Py_None;
14262 return resultobj;
14263 fail:
14264 return NULL;
14265 }
14266
14267
14268 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14269 PyObject *resultobj;
14270 wxDC *arg1 = (wxDC *) 0 ;
14271 wxRect *arg2 = 0 ;
14272 wxRect temp2 ;
14273 PyObject * obj0 = 0 ;
14274 PyObject * obj1 = 0 ;
14275 char *kwnames[] = {
14276 (char *) "self",(char *) "rect", NULL
14277 };
14278
14279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14281 if (SWIG_arg_fail(1)) SWIG_fail;
14282 {
14283 arg2 = &temp2;
14284 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14285 }
14286 {
14287 PyThreadState* __tstate = wxPyBeginAllowThreads();
14288 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14289
14290 wxPyEndAllowThreads(__tstate);
14291 if (PyErr_Occurred()) SWIG_fail;
14292 }
14293 Py_INCREF(Py_None); resultobj = Py_None;
14294 return resultobj;
14295 fail:
14296 return NULL;
14297 }
14298
14299
14300 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14301 PyObject *resultobj;
14302 wxDC *arg1 = (wxDC *) 0 ;
14303 int arg2 ;
14304 wxPoint *arg3 = (wxPoint *) 0 ;
14305 int arg4 = (int) 0 ;
14306 int arg5 = (int) 0 ;
14307 PyObject * obj0 = 0 ;
14308 PyObject * obj1 = 0 ;
14309 PyObject * obj2 = 0 ;
14310 PyObject * obj3 = 0 ;
14311 char *kwnames[] = {
14312 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14313 };
14314
14315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14317 if (SWIG_arg_fail(1)) SWIG_fail;
14318 {
14319 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14320 if (arg3 == NULL) SWIG_fail;
14321 }
14322 if (obj2) {
14323 {
14324 arg4 = (int)(SWIG_As_int(obj2));
14325 if (SWIG_arg_fail(4)) SWIG_fail;
14326 }
14327 }
14328 if (obj3) {
14329 {
14330 arg5 = (int)(SWIG_As_int(obj3));
14331 if (SWIG_arg_fail(5)) SWIG_fail;
14332 }
14333 }
14334 {
14335 PyThreadState* __tstate = wxPyBeginAllowThreads();
14336 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14337
14338 wxPyEndAllowThreads(__tstate);
14339 if (PyErr_Occurred()) SWIG_fail;
14340 }
14341 Py_INCREF(Py_None); resultobj = Py_None;
14342 {
14343 if (arg3) delete [] arg3;
14344 }
14345 return resultobj;
14346 fail:
14347 {
14348 if (arg3) delete [] arg3;
14349 }
14350 return NULL;
14351 }
14352
14353
14354 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14355 PyObject *resultobj;
14356 wxDC *arg1 = (wxDC *) 0 ;
14357 int arg2 ;
14358 wxPoint *arg3 = (wxPoint *) 0 ;
14359 int arg4 = (int) 0 ;
14360 int arg5 = (int) 0 ;
14361 int arg6 = (int) wxODDEVEN_RULE ;
14362 PyObject * obj0 = 0 ;
14363 PyObject * obj1 = 0 ;
14364 PyObject * obj2 = 0 ;
14365 PyObject * obj3 = 0 ;
14366 PyObject * obj4 = 0 ;
14367 char *kwnames[] = {
14368 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14369 };
14370
14371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14373 if (SWIG_arg_fail(1)) SWIG_fail;
14374 {
14375 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14376 if (arg3 == NULL) SWIG_fail;
14377 }
14378 if (obj2) {
14379 {
14380 arg4 = (int)(SWIG_As_int(obj2));
14381 if (SWIG_arg_fail(4)) SWIG_fail;
14382 }
14383 }
14384 if (obj3) {
14385 {
14386 arg5 = (int)(SWIG_As_int(obj3));
14387 if (SWIG_arg_fail(5)) SWIG_fail;
14388 }
14389 }
14390 if (obj4) {
14391 {
14392 arg6 = (int)(SWIG_As_int(obj4));
14393 if (SWIG_arg_fail(6)) SWIG_fail;
14394 }
14395 }
14396 {
14397 PyThreadState* __tstate = wxPyBeginAllowThreads();
14398 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14399
14400 wxPyEndAllowThreads(__tstate);
14401 if (PyErr_Occurred()) SWIG_fail;
14402 }
14403 Py_INCREF(Py_None); resultobj = Py_None;
14404 {
14405 if (arg3) delete [] arg3;
14406 }
14407 return resultobj;
14408 fail:
14409 {
14410 if (arg3) delete [] arg3;
14411 }
14412 return NULL;
14413 }
14414
14415
14416 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14417 PyObject *resultobj;
14418 wxDC *arg1 = (wxDC *) 0 ;
14419 wxString *arg2 = 0 ;
14420 wxRect *arg3 = 0 ;
14421 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14422 int arg5 = (int) -1 ;
14423 bool temp2 = false ;
14424 wxRect temp3 ;
14425 PyObject * obj0 = 0 ;
14426 PyObject * obj1 = 0 ;
14427 PyObject * obj2 = 0 ;
14428 PyObject * obj3 = 0 ;
14429 PyObject * obj4 = 0 ;
14430 char *kwnames[] = {
14431 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14432 };
14433
14434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14436 if (SWIG_arg_fail(1)) SWIG_fail;
14437 {
14438 arg2 = wxString_in_helper(obj1);
14439 if (arg2 == NULL) SWIG_fail;
14440 temp2 = true;
14441 }
14442 {
14443 arg3 = &temp3;
14444 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
14445 }
14446 if (obj3) {
14447 {
14448 arg4 = (int)(SWIG_As_int(obj3));
14449 if (SWIG_arg_fail(4)) SWIG_fail;
14450 }
14451 }
14452 if (obj4) {
14453 {
14454 arg5 = (int)(SWIG_As_int(obj4));
14455 if (SWIG_arg_fail(5)) SWIG_fail;
14456 }
14457 }
14458 {
14459 PyThreadState* __tstate = wxPyBeginAllowThreads();
14460 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
14461
14462 wxPyEndAllowThreads(__tstate);
14463 if (PyErr_Occurred()) SWIG_fail;
14464 }
14465 Py_INCREF(Py_None); resultobj = Py_None;
14466 {
14467 if (temp2)
14468 delete arg2;
14469 }
14470 return resultobj;
14471 fail:
14472 {
14473 if (temp2)
14474 delete arg2;
14475 }
14476 return NULL;
14477 }
14478
14479
14480 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14481 PyObject *resultobj;
14482 wxDC *arg1 = (wxDC *) 0 ;
14483 wxString *arg2 = 0 ;
14484 wxBitmap *arg3 = 0 ;
14485 wxRect *arg4 = 0 ;
14486 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14487 int arg6 = (int) -1 ;
14488 wxRect result;
14489 bool temp2 = false ;
14490 wxRect temp4 ;
14491 PyObject * obj0 = 0 ;
14492 PyObject * obj1 = 0 ;
14493 PyObject * obj2 = 0 ;
14494 PyObject * obj3 = 0 ;
14495 PyObject * obj4 = 0 ;
14496 PyObject * obj5 = 0 ;
14497 char *kwnames[] = {
14498 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14499 };
14500
14501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14503 if (SWIG_arg_fail(1)) SWIG_fail;
14504 {
14505 arg2 = wxString_in_helper(obj1);
14506 if (arg2 == NULL) SWIG_fail;
14507 temp2 = true;
14508 }
14509 {
14510 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14511 if (SWIG_arg_fail(3)) SWIG_fail;
14512 if (arg3 == NULL) {
14513 SWIG_null_ref("wxBitmap");
14514 }
14515 if (SWIG_arg_fail(3)) SWIG_fail;
14516 }
14517 {
14518 arg4 = &temp4;
14519 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
14520 }
14521 if (obj4) {
14522 {
14523 arg5 = (int)(SWIG_As_int(obj4));
14524 if (SWIG_arg_fail(5)) SWIG_fail;
14525 }
14526 }
14527 if (obj5) {
14528 {
14529 arg6 = (int)(SWIG_As_int(obj5));
14530 if (SWIG_arg_fail(6)) SWIG_fail;
14531 }
14532 }
14533 {
14534 PyThreadState* __tstate = wxPyBeginAllowThreads();
14535 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
14536
14537 wxPyEndAllowThreads(__tstate);
14538 if (PyErr_Occurred()) SWIG_fail;
14539 }
14540 {
14541 wxRect * resultptr;
14542 resultptr = new wxRect((wxRect &)(result));
14543 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14544 }
14545 {
14546 if (temp2)
14547 delete arg2;
14548 }
14549 return resultobj;
14550 fail:
14551 {
14552 if (temp2)
14553 delete arg2;
14554 }
14555 return NULL;
14556 }
14557
14558
14559 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
14560 PyObject *resultobj;
14561 wxDC *arg1 = (wxDC *) 0 ;
14562 int arg2 ;
14563 wxPoint *arg3 = (wxPoint *) 0 ;
14564 PyObject * obj0 = 0 ;
14565 PyObject * obj1 = 0 ;
14566 char *kwnames[] = {
14567 (char *) "self",(char *) "points", NULL
14568 };
14569
14570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
14571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14572 if (SWIG_arg_fail(1)) SWIG_fail;
14573 {
14574 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14575 if (arg3 == NULL) SWIG_fail;
14576 }
14577 {
14578 PyThreadState* __tstate = wxPyBeginAllowThreads();
14579 (arg1)->DrawSpline(arg2,arg3);
14580
14581 wxPyEndAllowThreads(__tstate);
14582 if (PyErr_Occurred()) SWIG_fail;
14583 }
14584 Py_INCREF(Py_None); resultobj = Py_None;
14585 {
14586 if (arg3) delete [] arg3;
14587 }
14588 return resultobj;
14589 fail:
14590 {
14591 if (arg3) delete [] arg3;
14592 }
14593 return NULL;
14594 }
14595
14596
14597 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
14598 PyObject *resultobj;
14599 wxDC *arg1 = (wxDC *) 0 ;
14600 PyObject * obj0 = 0 ;
14601 char *kwnames[] = {
14602 (char *) "self", NULL
14603 };
14604
14605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
14606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14607 if (SWIG_arg_fail(1)) SWIG_fail;
14608 {
14609 PyThreadState* __tstate = wxPyBeginAllowThreads();
14610 (arg1)->Clear();
14611
14612 wxPyEndAllowThreads(__tstate);
14613 if (PyErr_Occurred()) SWIG_fail;
14614 }
14615 Py_INCREF(Py_None); resultobj = Py_None;
14616 return resultobj;
14617 fail:
14618 return NULL;
14619 }
14620
14621
14622 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14623 PyObject *resultobj;
14624 wxDC *arg1 = (wxDC *) 0 ;
14625 wxString *arg2 = 0 ;
14626 bool result;
14627 bool temp2 = false ;
14628 PyObject * obj0 = 0 ;
14629 PyObject * obj1 = 0 ;
14630 char *kwnames[] = {
14631 (char *) "self",(char *) "message", NULL
14632 };
14633
14634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
14635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14636 if (SWIG_arg_fail(1)) SWIG_fail;
14637 {
14638 arg2 = wxString_in_helper(obj1);
14639 if (arg2 == NULL) SWIG_fail;
14640 temp2 = true;
14641 }
14642 {
14643 PyThreadState* __tstate = wxPyBeginAllowThreads();
14644 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
14645
14646 wxPyEndAllowThreads(__tstate);
14647 if (PyErr_Occurred()) SWIG_fail;
14648 }
14649 {
14650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14651 }
14652 {
14653 if (temp2)
14654 delete arg2;
14655 }
14656 return resultobj;
14657 fail:
14658 {
14659 if (temp2)
14660 delete arg2;
14661 }
14662 return NULL;
14663 }
14664
14665
14666 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14667 PyObject *resultobj;
14668 wxDC *arg1 = (wxDC *) 0 ;
14669 PyObject * obj0 = 0 ;
14670 char *kwnames[] = {
14671 (char *) "self", NULL
14672 };
14673
14674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
14675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14676 if (SWIG_arg_fail(1)) SWIG_fail;
14677 {
14678 PyThreadState* __tstate = wxPyBeginAllowThreads();
14679 (arg1)->EndDoc();
14680
14681 wxPyEndAllowThreads(__tstate);
14682 if (PyErr_Occurred()) SWIG_fail;
14683 }
14684 Py_INCREF(Py_None); resultobj = Py_None;
14685 return resultobj;
14686 fail:
14687 return NULL;
14688 }
14689
14690
14691 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
14692 PyObject *resultobj;
14693 wxDC *arg1 = (wxDC *) 0 ;
14694 PyObject * obj0 = 0 ;
14695 char *kwnames[] = {
14696 (char *) "self", NULL
14697 };
14698
14699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
14700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14701 if (SWIG_arg_fail(1)) SWIG_fail;
14702 {
14703 PyThreadState* __tstate = wxPyBeginAllowThreads();
14704 (arg1)->StartPage();
14705
14706 wxPyEndAllowThreads(__tstate);
14707 if (PyErr_Occurred()) SWIG_fail;
14708 }
14709 Py_INCREF(Py_None); resultobj = Py_None;
14710 return resultobj;
14711 fail:
14712 return NULL;
14713 }
14714
14715
14716 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
14717 PyObject *resultobj;
14718 wxDC *arg1 = (wxDC *) 0 ;
14719 PyObject * obj0 = 0 ;
14720 char *kwnames[] = {
14721 (char *) "self", NULL
14722 };
14723
14724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
14725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14726 if (SWIG_arg_fail(1)) SWIG_fail;
14727 {
14728 PyThreadState* __tstate = wxPyBeginAllowThreads();
14729 (arg1)->EndPage();
14730
14731 wxPyEndAllowThreads(__tstate);
14732 if (PyErr_Occurred()) SWIG_fail;
14733 }
14734 Py_INCREF(Py_None); resultobj = Py_None;
14735 return resultobj;
14736 fail:
14737 return NULL;
14738 }
14739
14740
14741 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
14742 PyObject *resultobj;
14743 wxDC *arg1 = (wxDC *) 0 ;
14744 wxFont *arg2 = 0 ;
14745 PyObject * obj0 = 0 ;
14746 PyObject * obj1 = 0 ;
14747 char *kwnames[] = {
14748 (char *) "self",(char *) "font", NULL
14749 };
14750
14751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
14752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14753 if (SWIG_arg_fail(1)) SWIG_fail;
14754 {
14755 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14756 if (SWIG_arg_fail(2)) SWIG_fail;
14757 if (arg2 == NULL) {
14758 SWIG_null_ref("wxFont");
14759 }
14760 if (SWIG_arg_fail(2)) SWIG_fail;
14761 }
14762 {
14763 PyThreadState* __tstate = wxPyBeginAllowThreads();
14764 (arg1)->SetFont((wxFont const &)*arg2);
14765
14766 wxPyEndAllowThreads(__tstate);
14767 if (PyErr_Occurred()) SWIG_fail;
14768 }
14769 Py_INCREF(Py_None); resultobj = Py_None;
14770 return resultobj;
14771 fail:
14772 return NULL;
14773 }
14774
14775
14776 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
14777 PyObject *resultobj;
14778 wxDC *arg1 = (wxDC *) 0 ;
14779 wxPen *arg2 = 0 ;
14780 PyObject * obj0 = 0 ;
14781 PyObject * obj1 = 0 ;
14782 char *kwnames[] = {
14783 (char *) "self",(char *) "pen", NULL
14784 };
14785
14786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
14787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14788 if (SWIG_arg_fail(1)) SWIG_fail;
14789 {
14790 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
14791 if (SWIG_arg_fail(2)) SWIG_fail;
14792 if (arg2 == NULL) {
14793 SWIG_null_ref("wxPen");
14794 }
14795 if (SWIG_arg_fail(2)) SWIG_fail;
14796 }
14797 {
14798 PyThreadState* __tstate = wxPyBeginAllowThreads();
14799 (arg1)->SetPen((wxPen const &)*arg2);
14800
14801 wxPyEndAllowThreads(__tstate);
14802 if (PyErr_Occurred()) SWIG_fail;
14803 }
14804 Py_INCREF(Py_None); resultobj = Py_None;
14805 return resultobj;
14806 fail:
14807 return NULL;
14808 }
14809
14810
14811 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
14812 PyObject *resultobj;
14813 wxDC *arg1 = (wxDC *) 0 ;
14814 wxBrush *arg2 = 0 ;
14815 PyObject * obj0 = 0 ;
14816 PyObject * obj1 = 0 ;
14817 char *kwnames[] = {
14818 (char *) "self",(char *) "brush", NULL
14819 };
14820
14821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
14822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14823 if (SWIG_arg_fail(1)) SWIG_fail;
14824 {
14825 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14826 if (SWIG_arg_fail(2)) SWIG_fail;
14827 if (arg2 == NULL) {
14828 SWIG_null_ref("wxBrush");
14829 }
14830 if (SWIG_arg_fail(2)) SWIG_fail;
14831 }
14832 {
14833 PyThreadState* __tstate = wxPyBeginAllowThreads();
14834 (arg1)->SetBrush((wxBrush const &)*arg2);
14835
14836 wxPyEndAllowThreads(__tstate);
14837 if (PyErr_Occurred()) SWIG_fail;
14838 }
14839 Py_INCREF(Py_None); resultobj = Py_None;
14840 return resultobj;
14841 fail:
14842 return NULL;
14843 }
14844
14845
14846 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
14847 PyObject *resultobj;
14848 wxDC *arg1 = (wxDC *) 0 ;
14849 wxBrush *arg2 = 0 ;
14850 PyObject * obj0 = 0 ;
14851 PyObject * obj1 = 0 ;
14852 char *kwnames[] = {
14853 (char *) "self",(char *) "brush", NULL
14854 };
14855
14856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
14857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14858 if (SWIG_arg_fail(1)) SWIG_fail;
14859 {
14860 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14861 if (SWIG_arg_fail(2)) SWIG_fail;
14862 if (arg2 == NULL) {
14863 SWIG_null_ref("wxBrush");
14864 }
14865 if (SWIG_arg_fail(2)) SWIG_fail;
14866 }
14867 {
14868 PyThreadState* __tstate = wxPyBeginAllowThreads();
14869 (arg1)->SetBackground((wxBrush const &)*arg2);
14870
14871 wxPyEndAllowThreads(__tstate);
14872 if (PyErr_Occurred()) SWIG_fail;
14873 }
14874 Py_INCREF(Py_None); resultobj = Py_None;
14875 return resultobj;
14876 fail:
14877 return NULL;
14878 }
14879
14880
14881 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
14882 PyObject *resultobj;
14883 wxDC *arg1 = (wxDC *) 0 ;
14884 int arg2 ;
14885 PyObject * obj0 = 0 ;
14886 PyObject * obj1 = 0 ;
14887 char *kwnames[] = {
14888 (char *) "self",(char *) "mode", NULL
14889 };
14890
14891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
14892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14893 if (SWIG_arg_fail(1)) SWIG_fail;
14894 {
14895 arg2 = (int)(SWIG_As_int(obj1));
14896 if (SWIG_arg_fail(2)) SWIG_fail;
14897 }
14898 {
14899 PyThreadState* __tstate = wxPyBeginAllowThreads();
14900 (arg1)->SetBackgroundMode(arg2);
14901
14902 wxPyEndAllowThreads(__tstate);
14903 if (PyErr_Occurred()) SWIG_fail;
14904 }
14905 Py_INCREF(Py_None); resultobj = Py_None;
14906 return resultobj;
14907 fail:
14908 return NULL;
14909 }
14910
14911
14912 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
14913 PyObject *resultobj;
14914 wxDC *arg1 = (wxDC *) 0 ;
14915 wxPalette *arg2 = 0 ;
14916 PyObject * obj0 = 0 ;
14917 PyObject * obj1 = 0 ;
14918 char *kwnames[] = {
14919 (char *) "self",(char *) "palette", NULL
14920 };
14921
14922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
14923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14924 if (SWIG_arg_fail(1)) SWIG_fail;
14925 {
14926 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
14927 if (SWIG_arg_fail(2)) SWIG_fail;
14928 if (arg2 == NULL) {
14929 SWIG_null_ref("wxPalette");
14930 }
14931 if (SWIG_arg_fail(2)) SWIG_fail;
14932 }
14933 {
14934 PyThreadState* __tstate = wxPyBeginAllowThreads();
14935 (arg1)->SetPalette((wxPalette const &)*arg2);
14936
14937 wxPyEndAllowThreads(__tstate);
14938 if (PyErr_Occurred()) SWIG_fail;
14939 }
14940 Py_INCREF(Py_None); resultobj = Py_None;
14941 return resultobj;
14942 fail:
14943 return NULL;
14944 }
14945
14946
14947 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14948 PyObject *resultobj;
14949 wxDC *arg1 = (wxDC *) 0 ;
14950 PyObject * obj0 = 0 ;
14951 char *kwnames[] = {
14952 (char *) "self", NULL
14953 };
14954
14955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
14956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14957 if (SWIG_arg_fail(1)) SWIG_fail;
14958 {
14959 PyThreadState* __tstate = wxPyBeginAllowThreads();
14960 (arg1)->DestroyClippingRegion();
14961
14962 wxPyEndAllowThreads(__tstate);
14963 if (PyErr_Occurred()) SWIG_fail;
14964 }
14965 Py_INCREF(Py_None); resultobj = Py_None;
14966 return resultobj;
14967 fail:
14968 return NULL;
14969 }
14970
14971
14972 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
14973 PyObject *resultobj;
14974 wxDC *arg1 = (wxDC *) 0 ;
14975 int *arg2 = (int *) 0 ;
14976 int *arg3 = (int *) 0 ;
14977 int *arg4 = (int *) 0 ;
14978 int *arg5 = (int *) 0 ;
14979 int temp2 ;
14980 int res2 = 0 ;
14981 int temp3 ;
14982 int res3 = 0 ;
14983 int temp4 ;
14984 int res4 = 0 ;
14985 int temp5 ;
14986 int res5 = 0 ;
14987 PyObject * obj0 = 0 ;
14988 char *kwnames[] = {
14989 (char *) "self", NULL
14990 };
14991
14992 arg2 = &temp2; res2 = SWIG_NEWOBJ;
14993 arg3 = &temp3; res3 = SWIG_NEWOBJ;
14994 arg4 = &temp4; res4 = SWIG_NEWOBJ;
14995 arg5 = &temp5; res5 = SWIG_NEWOBJ;
14996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
14997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14998 if (SWIG_arg_fail(1)) SWIG_fail;
14999 {
15000 PyThreadState* __tstate = wxPyBeginAllowThreads();
15001 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
15002
15003 wxPyEndAllowThreads(__tstate);
15004 if (PyErr_Occurred()) SWIG_fail;
15005 }
15006 Py_INCREF(Py_None); resultobj = Py_None;
15007 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15008 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15009 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15010 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15011 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15012 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15013 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15014 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15015 return resultobj;
15016 fail:
15017 return NULL;
15018 }
15019
15020
15021 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
15022 PyObject *resultobj;
15023 wxDC *arg1 = (wxDC *) 0 ;
15024 wxRect result;
15025 PyObject * obj0 = 0 ;
15026 char *kwnames[] = {
15027 (char *) "self", NULL
15028 };
15029
15030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
15031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15032 if (SWIG_arg_fail(1)) SWIG_fail;
15033 {
15034 PyThreadState* __tstate = wxPyBeginAllowThreads();
15035 result = wxDC_GetClippingRect(arg1);
15036
15037 wxPyEndAllowThreads(__tstate);
15038 if (PyErr_Occurred()) SWIG_fail;
15039 }
15040 {
15041 wxRect * resultptr;
15042 resultptr = new wxRect((wxRect &)(result));
15043 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15044 }
15045 return resultobj;
15046 fail:
15047 return NULL;
15048 }
15049
15050
15051 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
15052 PyObject *resultobj;
15053 wxDC *arg1 = (wxDC *) 0 ;
15054 int result;
15055 PyObject * obj0 = 0 ;
15056 char *kwnames[] = {
15057 (char *) "self", NULL
15058 };
15059
15060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
15061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15062 if (SWIG_arg_fail(1)) SWIG_fail;
15063 {
15064 PyThreadState* __tstate = wxPyBeginAllowThreads();
15065 result = (int)((wxDC const *)arg1)->GetCharHeight();
15066
15067 wxPyEndAllowThreads(__tstate);
15068 if (PyErr_Occurred()) SWIG_fail;
15069 }
15070 {
15071 resultobj = SWIG_From_int((int)(result));
15072 }
15073 return resultobj;
15074 fail:
15075 return NULL;
15076 }
15077
15078
15079 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
15080 PyObject *resultobj;
15081 wxDC *arg1 = (wxDC *) 0 ;
15082 int result;
15083 PyObject * obj0 = 0 ;
15084 char *kwnames[] = {
15085 (char *) "self", NULL
15086 };
15087
15088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
15089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15090 if (SWIG_arg_fail(1)) SWIG_fail;
15091 {
15092 PyThreadState* __tstate = wxPyBeginAllowThreads();
15093 result = (int)((wxDC const *)arg1)->GetCharWidth();
15094
15095 wxPyEndAllowThreads(__tstate);
15096 if (PyErr_Occurred()) SWIG_fail;
15097 }
15098 {
15099 resultobj = SWIG_From_int((int)(result));
15100 }
15101 return resultobj;
15102 fail:
15103 return NULL;
15104 }
15105
15106
15107 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15108 PyObject *resultobj;
15109 wxDC *arg1 = (wxDC *) 0 ;
15110 wxString *arg2 = 0 ;
15111 int *arg3 = (int *) 0 ;
15112 int *arg4 = (int *) 0 ;
15113 bool temp2 = false ;
15114 int temp3 ;
15115 int res3 = 0 ;
15116 int temp4 ;
15117 int res4 = 0 ;
15118 PyObject * obj0 = 0 ;
15119 PyObject * obj1 = 0 ;
15120 char *kwnames[] = {
15121 (char *) "self",(char *) "string", NULL
15122 };
15123
15124 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15125 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15128 if (SWIG_arg_fail(1)) SWIG_fail;
15129 {
15130 arg2 = wxString_in_helper(obj1);
15131 if (arg2 == NULL) SWIG_fail;
15132 temp2 = true;
15133 }
15134 {
15135 PyThreadState* __tstate = wxPyBeginAllowThreads();
15136 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15137
15138 wxPyEndAllowThreads(__tstate);
15139 if (PyErr_Occurred()) SWIG_fail;
15140 }
15141 Py_INCREF(Py_None); resultobj = Py_None;
15142 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15143 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15144 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15145 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15146 {
15147 if (temp2)
15148 delete arg2;
15149 }
15150 return resultobj;
15151 fail:
15152 {
15153 if (temp2)
15154 delete arg2;
15155 }
15156 return NULL;
15157 }
15158
15159
15160 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15161 PyObject *resultobj;
15162 wxDC *arg1 = (wxDC *) 0 ;
15163 wxString *arg2 = 0 ;
15164 int *arg3 = (int *) 0 ;
15165 int *arg4 = (int *) 0 ;
15166 int *arg5 = (int *) 0 ;
15167 int *arg6 = (int *) 0 ;
15168 wxFont *arg7 = (wxFont *) NULL ;
15169 bool temp2 = false ;
15170 int temp3 ;
15171 int res3 = 0 ;
15172 int temp4 ;
15173 int res4 = 0 ;
15174 int temp5 ;
15175 int res5 = 0 ;
15176 int temp6 ;
15177 int res6 = 0 ;
15178 PyObject * obj0 = 0 ;
15179 PyObject * obj1 = 0 ;
15180 PyObject * obj2 = 0 ;
15181 char *kwnames[] = {
15182 (char *) "self",(char *) "string",(char *) "font", NULL
15183 };
15184
15185 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15186 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15187 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15188 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15191 if (SWIG_arg_fail(1)) SWIG_fail;
15192 {
15193 arg2 = wxString_in_helper(obj1);
15194 if (arg2 == NULL) SWIG_fail;
15195 temp2 = true;
15196 }
15197 if (obj2) {
15198 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15199 if (SWIG_arg_fail(7)) SWIG_fail;
15200 }
15201 {
15202 PyThreadState* __tstate = wxPyBeginAllowThreads();
15203 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15204
15205 wxPyEndAllowThreads(__tstate);
15206 if (PyErr_Occurred()) SWIG_fail;
15207 }
15208 Py_INCREF(Py_None); resultobj = Py_None;
15209 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15210 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15211 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15212 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15213 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15214 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15215 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15216 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15217 {
15218 if (temp2)
15219 delete arg2;
15220 }
15221 return resultobj;
15222 fail:
15223 {
15224 if (temp2)
15225 delete arg2;
15226 }
15227 return NULL;
15228 }
15229
15230
15231 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15232 PyObject *resultobj;
15233 wxDC *arg1 = (wxDC *) 0 ;
15234 wxString *arg2 = 0 ;
15235 int *arg3 = (int *) 0 ;
15236 int *arg4 = (int *) 0 ;
15237 int *arg5 = (int *) 0 ;
15238 wxFont *arg6 = (wxFont *) NULL ;
15239 bool temp2 = false ;
15240 int temp3 ;
15241 int res3 = 0 ;
15242 int temp4 ;
15243 int res4 = 0 ;
15244 int temp5 ;
15245 int res5 = 0 ;
15246 PyObject * obj0 = 0 ;
15247 PyObject * obj1 = 0 ;
15248 PyObject * obj2 = 0 ;
15249 char *kwnames[] = {
15250 (char *) "self",(char *) "text",(char *) "font", NULL
15251 };
15252
15253 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15254 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15255 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15258 if (SWIG_arg_fail(1)) SWIG_fail;
15259 {
15260 arg2 = wxString_in_helper(obj1);
15261 if (arg2 == NULL) SWIG_fail;
15262 temp2 = true;
15263 }
15264 if (obj2) {
15265 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15266 if (SWIG_arg_fail(6)) SWIG_fail;
15267 }
15268 {
15269 PyThreadState* __tstate = wxPyBeginAllowThreads();
15270 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15271
15272 wxPyEndAllowThreads(__tstate);
15273 if (PyErr_Occurred()) SWIG_fail;
15274 }
15275 Py_INCREF(Py_None); resultobj = Py_None;
15276 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15277 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15278 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15279 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15280 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15281 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15282 {
15283 if (temp2)
15284 delete arg2;
15285 }
15286 return resultobj;
15287 fail:
15288 {
15289 if (temp2)
15290 delete arg2;
15291 }
15292 return NULL;
15293 }
15294
15295
15296 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15297 PyObject *resultobj;
15298 wxDC *arg1 = (wxDC *) 0 ;
15299 wxString *arg2 = 0 ;
15300 wxArrayInt result;
15301 bool temp2 = false ;
15302 PyObject * obj0 = 0 ;
15303 PyObject * obj1 = 0 ;
15304 char *kwnames[] = {
15305 (char *) "self",(char *) "text", NULL
15306 };
15307
15308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15310 if (SWIG_arg_fail(1)) SWIG_fail;
15311 {
15312 arg2 = wxString_in_helper(obj1);
15313 if (arg2 == NULL) SWIG_fail;
15314 temp2 = true;
15315 }
15316 {
15317 PyThreadState* __tstate = wxPyBeginAllowThreads();
15318 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15319
15320 wxPyEndAllowThreads(__tstate);
15321 if (PyErr_Occurred()) SWIG_fail;
15322 }
15323 {
15324 resultobj = PyList_New(0);
15325 size_t idx;
15326 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15327 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15328 PyList_Append(resultobj, val);
15329 Py_DECREF(val);
15330 }
15331 }
15332 {
15333 if (temp2)
15334 delete arg2;
15335 }
15336 return resultobj;
15337 fail:
15338 {
15339 if (temp2)
15340 delete arg2;
15341 }
15342 return NULL;
15343 }
15344
15345
15346 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15347 PyObject *resultobj;
15348 wxDC *arg1 = (wxDC *) 0 ;
15349 wxSize result;
15350 PyObject * obj0 = 0 ;
15351 char *kwnames[] = {
15352 (char *) "self", NULL
15353 };
15354
15355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15357 if (SWIG_arg_fail(1)) SWIG_fail;
15358 {
15359 PyThreadState* __tstate = wxPyBeginAllowThreads();
15360 result = (arg1)->GetSize();
15361
15362 wxPyEndAllowThreads(__tstate);
15363 if (PyErr_Occurred()) SWIG_fail;
15364 }
15365 {
15366 wxSize * resultptr;
15367 resultptr = new wxSize((wxSize &)(result));
15368 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15369 }
15370 return resultobj;
15371 fail:
15372 return NULL;
15373 }
15374
15375
15376 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15377 PyObject *resultobj;
15378 wxDC *arg1 = (wxDC *) 0 ;
15379 int *arg2 = (int *) 0 ;
15380 int *arg3 = (int *) 0 ;
15381 int temp2 ;
15382 int res2 = 0 ;
15383 int temp3 ;
15384 int res3 = 0 ;
15385 PyObject * obj0 = 0 ;
15386 char *kwnames[] = {
15387 (char *) "self", NULL
15388 };
15389
15390 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15391 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15394 if (SWIG_arg_fail(1)) SWIG_fail;
15395 {
15396 PyThreadState* __tstate = wxPyBeginAllowThreads();
15397 (arg1)->GetSize(arg2,arg3);
15398
15399 wxPyEndAllowThreads(__tstate);
15400 if (PyErr_Occurred()) SWIG_fail;
15401 }
15402 Py_INCREF(Py_None); resultobj = Py_None;
15403 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15404 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15405 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15406 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15407 return resultobj;
15408 fail:
15409 return NULL;
15410 }
15411
15412
15413 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15414 PyObject *resultobj;
15415 wxDC *arg1 = (wxDC *) 0 ;
15416 wxSize result;
15417 PyObject * obj0 = 0 ;
15418 char *kwnames[] = {
15419 (char *) "self", NULL
15420 };
15421
15422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
15423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15424 if (SWIG_arg_fail(1)) SWIG_fail;
15425 {
15426 PyThreadState* __tstate = wxPyBeginAllowThreads();
15427 result = ((wxDC const *)arg1)->GetSizeMM();
15428
15429 wxPyEndAllowThreads(__tstate);
15430 if (PyErr_Occurred()) SWIG_fail;
15431 }
15432 {
15433 wxSize * resultptr;
15434 resultptr = new wxSize((wxSize &)(result));
15435 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15436 }
15437 return resultobj;
15438 fail:
15439 return NULL;
15440 }
15441
15442
15443 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15444 PyObject *resultobj;
15445 wxDC *arg1 = (wxDC *) 0 ;
15446 int *arg2 = (int *) 0 ;
15447 int *arg3 = (int *) 0 ;
15448 int temp2 ;
15449 int res2 = 0 ;
15450 int temp3 ;
15451 int res3 = 0 ;
15452 PyObject * obj0 = 0 ;
15453 char *kwnames[] = {
15454 (char *) "self", NULL
15455 };
15456
15457 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15458 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
15460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15461 if (SWIG_arg_fail(1)) SWIG_fail;
15462 {
15463 PyThreadState* __tstate = wxPyBeginAllowThreads();
15464 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
15465
15466 wxPyEndAllowThreads(__tstate);
15467 if (PyErr_Occurred()) SWIG_fail;
15468 }
15469 Py_INCREF(Py_None); resultobj = Py_None;
15470 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15471 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15472 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15473 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15474 return resultobj;
15475 fail:
15476 return NULL;
15477 }
15478
15479
15480 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
15481 PyObject *resultobj;
15482 wxDC *arg1 = (wxDC *) 0 ;
15483 int arg2 ;
15484 int result;
15485 PyObject * obj0 = 0 ;
15486 PyObject * obj1 = 0 ;
15487 char *kwnames[] = {
15488 (char *) "self",(char *) "x", NULL
15489 };
15490
15491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
15492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15493 if (SWIG_arg_fail(1)) SWIG_fail;
15494 {
15495 arg2 = (int)(SWIG_As_int(obj1));
15496 if (SWIG_arg_fail(2)) SWIG_fail;
15497 }
15498 {
15499 PyThreadState* __tstate = wxPyBeginAllowThreads();
15500 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
15501
15502 wxPyEndAllowThreads(__tstate);
15503 if (PyErr_Occurred()) SWIG_fail;
15504 }
15505 {
15506 resultobj = SWIG_From_int((int)(result));
15507 }
15508 return resultobj;
15509 fail:
15510 return NULL;
15511 }
15512
15513
15514 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
15515 PyObject *resultobj;
15516 wxDC *arg1 = (wxDC *) 0 ;
15517 int arg2 ;
15518 int result;
15519 PyObject * obj0 = 0 ;
15520 PyObject * obj1 = 0 ;
15521 char *kwnames[] = {
15522 (char *) "self",(char *) "y", NULL
15523 };
15524
15525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
15526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15527 if (SWIG_arg_fail(1)) SWIG_fail;
15528 {
15529 arg2 = (int)(SWIG_As_int(obj1));
15530 if (SWIG_arg_fail(2)) SWIG_fail;
15531 }
15532 {
15533 PyThreadState* __tstate = wxPyBeginAllowThreads();
15534 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
15535
15536 wxPyEndAllowThreads(__tstate);
15537 if (PyErr_Occurred()) SWIG_fail;
15538 }
15539 {
15540 resultobj = SWIG_From_int((int)(result));
15541 }
15542 return resultobj;
15543 fail:
15544 return NULL;
15545 }
15546
15547
15548 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15549 PyObject *resultobj;
15550 wxDC *arg1 = (wxDC *) 0 ;
15551 int arg2 ;
15552 int result;
15553 PyObject * obj0 = 0 ;
15554 PyObject * obj1 = 0 ;
15555 char *kwnames[] = {
15556 (char *) "self",(char *) "x", NULL
15557 };
15558
15559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
15560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15561 if (SWIG_arg_fail(1)) SWIG_fail;
15562 {
15563 arg2 = (int)(SWIG_As_int(obj1));
15564 if (SWIG_arg_fail(2)) SWIG_fail;
15565 }
15566 {
15567 PyThreadState* __tstate = wxPyBeginAllowThreads();
15568 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
15569
15570 wxPyEndAllowThreads(__tstate);
15571 if (PyErr_Occurred()) SWIG_fail;
15572 }
15573 {
15574 resultobj = SWIG_From_int((int)(result));
15575 }
15576 return resultobj;
15577 fail:
15578 return NULL;
15579 }
15580
15581
15582 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15583 PyObject *resultobj;
15584 wxDC *arg1 = (wxDC *) 0 ;
15585 int arg2 ;
15586 int result;
15587 PyObject * obj0 = 0 ;
15588 PyObject * obj1 = 0 ;
15589 char *kwnames[] = {
15590 (char *) "self",(char *) "y", NULL
15591 };
15592
15593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
15594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15595 if (SWIG_arg_fail(1)) SWIG_fail;
15596 {
15597 arg2 = (int)(SWIG_As_int(obj1));
15598 if (SWIG_arg_fail(2)) SWIG_fail;
15599 }
15600 {
15601 PyThreadState* __tstate = wxPyBeginAllowThreads();
15602 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
15603
15604 wxPyEndAllowThreads(__tstate);
15605 if (PyErr_Occurred()) SWIG_fail;
15606 }
15607 {
15608 resultobj = SWIG_From_int((int)(result));
15609 }
15610 return resultobj;
15611 fail:
15612 return NULL;
15613 }
15614
15615
15616 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
15617 PyObject *resultobj;
15618 wxDC *arg1 = (wxDC *) 0 ;
15619 int arg2 ;
15620 int result;
15621 PyObject * obj0 = 0 ;
15622 PyObject * obj1 = 0 ;
15623 char *kwnames[] = {
15624 (char *) "self",(char *) "x", NULL
15625 };
15626
15627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
15628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15629 if (SWIG_arg_fail(1)) SWIG_fail;
15630 {
15631 arg2 = (int)(SWIG_As_int(obj1));
15632 if (SWIG_arg_fail(2)) SWIG_fail;
15633 }
15634 {
15635 PyThreadState* __tstate = wxPyBeginAllowThreads();
15636 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
15637
15638 wxPyEndAllowThreads(__tstate);
15639 if (PyErr_Occurred()) SWIG_fail;
15640 }
15641 {
15642 resultobj = SWIG_From_int((int)(result));
15643 }
15644 return resultobj;
15645 fail:
15646 return NULL;
15647 }
15648
15649
15650 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
15651 PyObject *resultobj;
15652 wxDC *arg1 = (wxDC *) 0 ;
15653 int arg2 ;
15654 int result;
15655 PyObject * obj0 = 0 ;
15656 PyObject * obj1 = 0 ;
15657 char *kwnames[] = {
15658 (char *) "self",(char *) "y", NULL
15659 };
15660
15661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
15662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15663 if (SWIG_arg_fail(1)) SWIG_fail;
15664 {
15665 arg2 = (int)(SWIG_As_int(obj1));
15666 if (SWIG_arg_fail(2)) SWIG_fail;
15667 }
15668 {
15669 PyThreadState* __tstate = wxPyBeginAllowThreads();
15670 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
15671
15672 wxPyEndAllowThreads(__tstate);
15673 if (PyErr_Occurred()) SWIG_fail;
15674 }
15675 {
15676 resultobj = SWIG_From_int((int)(result));
15677 }
15678 return resultobj;
15679 fail:
15680 return NULL;
15681 }
15682
15683
15684 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15685 PyObject *resultobj;
15686 wxDC *arg1 = (wxDC *) 0 ;
15687 int arg2 ;
15688 int result;
15689 PyObject * obj0 = 0 ;
15690 PyObject * obj1 = 0 ;
15691 char *kwnames[] = {
15692 (char *) "self",(char *) "x", NULL
15693 };
15694
15695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
15696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15697 if (SWIG_arg_fail(1)) SWIG_fail;
15698 {
15699 arg2 = (int)(SWIG_As_int(obj1));
15700 if (SWIG_arg_fail(2)) SWIG_fail;
15701 }
15702 {
15703 PyThreadState* __tstate = wxPyBeginAllowThreads();
15704 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
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_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15719 PyObject *resultobj;
15720 wxDC *arg1 = (wxDC *) 0 ;
15721 int arg2 ;
15722 int result;
15723 PyObject * obj0 = 0 ;
15724 PyObject * obj1 = 0 ;
15725 char *kwnames[] = {
15726 (char *) "self",(char *) "y", NULL
15727 };
15728
15729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
15730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15731 if (SWIG_arg_fail(1)) SWIG_fail;
15732 {
15733 arg2 = (int)(SWIG_As_int(obj1));
15734 if (SWIG_arg_fail(2)) SWIG_fail;
15735 }
15736 {
15737 PyThreadState* __tstate = wxPyBeginAllowThreads();
15738 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
15739
15740 wxPyEndAllowThreads(__tstate);
15741 if (PyErr_Occurred()) SWIG_fail;
15742 }
15743 {
15744 resultobj = SWIG_From_int((int)(result));
15745 }
15746 return resultobj;
15747 fail:
15748 return NULL;
15749 }
15750
15751
15752 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
15753 PyObject *resultobj;
15754 wxDC *arg1 = (wxDC *) 0 ;
15755 bool result;
15756 PyObject * obj0 = 0 ;
15757 char *kwnames[] = {
15758 (char *) "self", NULL
15759 };
15760
15761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
15762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15763 if (SWIG_arg_fail(1)) SWIG_fail;
15764 {
15765 PyThreadState* __tstate = wxPyBeginAllowThreads();
15766 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
15767
15768 wxPyEndAllowThreads(__tstate);
15769 if (PyErr_Occurred()) SWIG_fail;
15770 }
15771 {
15772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15773 }
15774 return resultobj;
15775 fail:
15776 return NULL;
15777 }
15778
15779
15780 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15781 PyObject *resultobj;
15782 wxDC *arg1 = (wxDC *) 0 ;
15783 bool result;
15784 PyObject * obj0 = 0 ;
15785 char *kwnames[] = {
15786 (char *) "self", NULL
15787 };
15788
15789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
15790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15791 if (SWIG_arg_fail(1)) SWIG_fail;
15792 {
15793 PyThreadState* __tstate = wxPyBeginAllowThreads();
15794 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
15795
15796 wxPyEndAllowThreads(__tstate);
15797 if (PyErr_Occurred()) SWIG_fail;
15798 }
15799 {
15800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15801 }
15802 return resultobj;
15803 fail:
15804 return NULL;
15805 }
15806
15807
15808 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
15809 PyObject *resultobj;
15810 wxDC *arg1 = (wxDC *) 0 ;
15811 int result;
15812 PyObject * obj0 = 0 ;
15813 char *kwnames[] = {
15814 (char *) "self", NULL
15815 };
15816
15817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
15818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15819 if (SWIG_arg_fail(1)) SWIG_fail;
15820 {
15821 PyThreadState* __tstate = wxPyBeginAllowThreads();
15822 result = (int)((wxDC const *)arg1)->GetDepth();
15823
15824 wxPyEndAllowThreads(__tstate);
15825 if (PyErr_Occurred()) SWIG_fail;
15826 }
15827 {
15828 resultobj = SWIG_From_int((int)(result));
15829 }
15830 return resultobj;
15831 fail:
15832 return NULL;
15833 }
15834
15835
15836 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
15837 PyObject *resultobj;
15838 wxDC *arg1 = (wxDC *) 0 ;
15839 wxSize result;
15840 PyObject * obj0 = 0 ;
15841 char *kwnames[] = {
15842 (char *) "self", NULL
15843 };
15844
15845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",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 result = ((wxDC const *)arg1)->GetPPI();
15851
15852 wxPyEndAllowThreads(__tstate);
15853 if (PyErr_Occurred()) SWIG_fail;
15854 }
15855 {
15856 wxSize * resultptr;
15857 resultptr = new wxSize((wxSize &)(result));
15858 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15859 }
15860 return resultobj;
15861 fail:
15862 return NULL;
15863 }
15864
15865
15866 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
15867 PyObject *resultobj;
15868 wxDC *arg1 = (wxDC *) 0 ;
15869 bool result;
15870 PyObject * obj0 = 0 ;
15871 char *kwnames[] = {
15872 (char *) "self", NULL
15873 };
15874
15875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
15876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15877 if (SWIG_arg_fail(1)) SWIG_fail;
15878 {
15879 PyThreadState* __tstate = wxPyBeginAllowThreads();
15880 result = (bool)((wxDC const *)arg1)->Ok();
15881
15882 wxPyEndAllowThreads(__tstate);
15883 if (PyErr_Occurred()) SWIG_fail;
15884 }
15885 {
15886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15887 }
15888 return resultobj;
15889 fail:
15890 return NULL;
15891 }
15892
15893
15894 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15895 PyObject *resultobj;
15896 wxDC *arg1 = (wxDC *) 0 ;
15897 int result;
15898 PyObject * obj0 = 0 ;
15899 char *kwnames[] = {
15900 (char *) "self", NULL
15901 };
15902
15903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
15904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15905 if (SWIG_arg_fail(1)) SWIG_fail;
15906 {
15907 PyThreadState* __tstate = wxPyBeginAllowThreads();
15908 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
15909
15910 wxPyEndAllowThreads(__tstate);
15911 if (PyErr_Occurred()) SWIG_fail;
15912 }
15913 {
15914 resultobj = SWIG_From_int((int)(result));
15915 }
15916 return resultobj;
15917 fail:
15918 return NULL;
15919 }
15920
15921
15922 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15923 PyObject *resultobj;
15924 wxDC *arg1 = (wxDC *) 0 ;
15925 wxBrush *result;
15926 PyObject * obj0 = 0 ;
15927 char *kwnames[] = {
15928 (char *) "self", NULL
15929 };
15930
15931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
15932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15933 if (SWIG_arg_fail(1)) SWIG_fail;
15934 {
15935 PyThreadState* __tstate = wxPyBeginAllowThreads();
15936 {
15937 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
15938 result = (wxBrush *) &_result_ref;
15939 }
15940
15941 wxPyEndAllowThreads(__tstate);
15942 if (PyErr_Occurred()) SWIG_fail;
15943 }
15944 {
15945 wxBrush* resultptr = new wxBrush(*result);
15946 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15947 }
15948 return resultobj;
15949 fail:
15950 return NULL;
15951 }
15952
15953
15954 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15955 PyObject *resultobj;
15956 wxDC *arg1 = (wxDC *) 0 ;
15957 wxBrush *result;
15958 PyObject * obj0 = 0 ;
15959 char *kwnames[] = {
15960 (char *) "self", NULL
15961 };
15962
15963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
15964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15965 if (SWIG_arg_fail(1)) SWIG_fail;
15966 {
15967 PyThreadState* __tstate = wxPyBeginAllowThreads();
15968 {
15969 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
15970 result = (wxBrush *) &_result_ref;
15971 }
15972
15973 wxPyEndAllowThreads(__tstate);
15974 if (PyErr_Occurred()) SWIG_fail;
15975 }
15976 {
15977 wxBrush* resultptr = new wxBrush(*result);
15978 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15979 }
15980 return resultobj;
15981 fail:
15982 return NULL;
15983 }
15984
15985
15986 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15987 PyObject *resultobj;
15988 wxDC *arg1 = (wxDC *) 0 ;
15989 wxFont *result;
15990 PyObject * obj0 = 0 ;
15991 char *kwnames[] = {
15992 (char *) "self", NULL
15993 };
15994
15995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
15996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15997 if (SWIG_arg_fail(1)) SWIG_fail;
15998 {
15999 PyThreadState* __tstate = wxPyBeginAllowThreads();
16000 {
16001 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
16002 result = (wxFont *) &_result_ref;
16003 }
16004
16005 wxPyEndAllowThreads(__tstate);
16006 if (PyErr_Occurred()) SWIG_fail;
16007 }
16008 {
16009 wxFont* resultptr = new wxFont(*result);
16010 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
16011 }
16012 return resultobj;
16013 fail:
16014 return NULL;
16015 }
16016
16017
16018 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
16019 PyObject *resultobj;
16020 wxDC *arg1 = (wxDC *) 0 ;
16021 wxPen *result;
16022 PyObject * obj0 = 0 ;
16023 char *kwnames[] = {
16024 (char *) "self", NULL
16025 };
16026
16027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
16028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16029 if (SWIG_arg_fail(1)) SWIG_fail;
16030 {
16031 PyThreadState* __tstate = wxPyBeginAllowThreads();
16032 {
16033 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
16034 result = (wxPen *) &_result_ref;
16035 }
16036
16037 wxPyEndAllowThreads(__tstate);
16038 if (PyErr_Occurred()) SWIG_fail;
16039 }
16040 {
16041 wxPen* resultptr = new wxPen(*result);
16042 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
16043 }
16044 return resultobj;
16045 fail:
16046 return NULL;
16047 }
16048
16049
16050 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16051 PyObject *resultobj;
16052 wxDC *arg1 = (wxDC *) 0 ;
16053 wxColour *result;
16054 PyObject * obj0 = 0 ;
16055 char *kwnames[] = {
16056 (char *) "self", NULL
16057 };
16058
16059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
16060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16061 if (SWIG_arg_fail(1)) SWIG_fail;
16062 {
16063 PyThreadState* __tstate = wxPyBeginAllowThreads();
16064 {
16065 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
16066 result = (wxColour *) &_result_ref;
16067 }
16068
16069 wxPyEndAllowThreads(__tstate);
16070 if (PyErr_Occurred()) SWIG_fail;
16071 }
16072 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16073 return resultobj;
16074 fail:
16075 return NULL;
16076 }
16077
16078
16079 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16080 PyObject *resultobj;
16081 wxDC *arg1 = (wxDC *) 0 ;
16082 wxColour *result;
16083 PyObject * obj0 = 0 ;
16084 char *kwnames[] = {
16085 (char *) "self", NULL
16086 };
16087
16088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
16089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16090 if (SWIG_arg_fail(1)) SWIG_fail;
16091 {
16092 PyThreadState* __tstate = wxPyBeginAllowThreads();
16093 {
16094 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
16095 result = (wxColour *) &_result_ref;
16096 }
16097
16098 wxPyEndAllowThreads(__tstate);
16099 if (PyErr_Occurred()) SWIG_fail;
16100 }
16101 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16102 return resultobj;
16103 fail:
16104 return NULL;
16105 }
16106
16107
16108 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16109 PyObject *resultobj;
16110 wxDC *arg1 = (wxDC *) 0 ;
16111 wxColour *arg2 = 0 ;
16112 wxColour temp2 ;
16113 PyObject * obj0 = 0 ;
16114 PyObject * obj1 = 0 ;
16115 char *kwnames[] = {
16116 (char *) "self",(char *) "colour", NULL
16117 };
16118
16119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16121 if (SWIG_arg_fail(1)) SWIG_fail;
16122 {
16123 arg2 = &temp2;
16124 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16125 }
16126 {
16127 PyThreadState* __tstate = wxPyBeginAllowThreads();
16128 (arg1)->SetTextForeground((wxColour const &)*arg2);
16129
16130 wxPyEndAllowThreads(__tstate);
16131 if (PyErr_Occurred()) SWIG_fail;
16132 }
16133 Py_INCREF(Py_None); resultobj = Py_None;
16134 return resultobj;
16135 fail:
16136 return NULL;
16137 }
16138
16139
16140 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16141 PyObject *resultobj;
16142 wxDC *arg1 = (wxDC *) 0 ;
16143 wxColour *arg2 = 0 ;
16144 wxColour temp2 ;
16145 PyObject * obj0 = 0 ;
16146 PyObject * obj1 = 0 ;
16147 char *kwnames[] = {
16148 (char *) "self",(char *) "colour", NULL
16149 };
16150
16151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16153 if (SWIG_arg_fail(1)) SWIG_fail;
16154 {
16155 arg2 = &temp2;
16156 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16157 }
16158 {
16159 PyThreadState* __tstate = wxPyBeginAllowThreads();
16160 (arg1)->SetTextBackground((wxColour const &)*arg2);
16161
16162 wxPyEndAllowThreads(__tstate);
16163 if (PyErr_Occurred()) SWIG_fail;
16164 }
16165 Py_INCREF(Py_None); resultobj = Py_None;
16166 return resultobj;
16167 fail:
16168 return NULL;
16169 }
16170
16171
16172 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16173 PyObject *resultobj;
16174 wxDC *arg1 = (wxDC *) 0 ;
16175 int result;
16176 PyObject * obj0 = 0 ;
16177 char *kwnames[] = {
16178 (char *) "self", NULL
16179 };
16180
16181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16183 if (SWIG_arg_fail(1)) SWIG_fail;
16184 {
16185 PyThreadState* __tstate = wxPyBeginAllowThreads();
16186 result = (int)((wxDC const *)arg1)->GetMapMode();
16187
16188 wxPyEndAllowThreads(__tstate);
16189 if (PyErr_Occurred()) SWIG_fail;
16190 }
16191 {
16192 resultobj = SWIG_From_int((int)(result));
16193 }
16194 return resultobj;
16195 fail:
16196 return NULL;
16197 }
16198
16199
16200 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16201 PyObject *resultobj;
16202 wxDC *arg1 = (wxDC *) 0 ;
16203 int arg2 ;
16204 PyObject * obj0 = 0 ;
16205 PyObject * obj1 = 0 ;
16206 char *kwnames[] = {
16207 (char *) "self",(char *) "mode", NULL
16208 };
16209
16210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16212 if (SWIG_arg_fail(1)) SWIG_fail;
16213 {
16214 arg2 = (int)(SWIG_As_int(obj1));
16215 if (SWIG_arg_fail(2)) SWIG_fail;
16216 }
16217 {
16218 PyThreadState* __tstate = wxPyBeginAllowThreads();
16219 (arg1)->SetMapMode(arg2);
16220
16221 wxPyEndAllowThreads(__tstate);
16222 if (PyErr_Occurred()) SWIG_fail;
16223 }
16224 Py_INCREF(Py_None); resultobj = Py_None;
16225 return resultobj;
16226 fail:
16227 return NULL;
16228 }
16229
16230
16231 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16232 PyObject *resultobj;
16233 wxDC *arg1 = (wxDC *) 0 ;
16234 double *arg2 = (double *) 0 ;
16235 double *arg3 = (double *) 0 ;
16236 double temp2 ;
16237 int res2 = 0 ;
16238 double temp3 ;
16239 int res3 = 0 ;
16240 PyObject * obj0 = 0 ;
16241 char *kwnames[] = {
16242 (char *) "self", NULL
16243 };
16244
16245 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16246 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16249 if (SWIG_arg_fail(1)) SWIG_fail;
16250 {
16251 PyThreadState* __tstate = wxPyBeginAllowThreads();
16252 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16253
16254 wxPyEndAllowThreads(__tstate);
16255 if (PyErr_Occurred()) SWIG_fail;
16256 }
16257 Py_INCREF(Py_None); resultobj = Py_None;
16258 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16259 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16260 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16261 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16262 return resultobj;
16263 fail:
16264 return NULL;
16265 }
16266
16267
16268 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16269 PyObject *resultobj;
16270 wxDC *arg1 = (wxDC *) 0 ;
16271 double arg2 ;
16272 double arg3 ;
16273 PyObject * obj0 = 0 ;
16274 PyObject * obj1 = 0 ;
16275 PyObject * obj2 = 0 ;
16276 char *kwnames[] = {
16277 (char *) "self",(char *) "x",(char *) "y", NULL
16278 };
16279
16280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16282 if (SWIG_arg_fail(1)) SWIG_fail;
16283 {
16284 arg2 = (double)(SWIG_As_double(obj1));
16285 if (SWIG_arg_fail(2)) SWIG_fail;
16286 }
16287 {
16288 arg3 = (double)(SWIG_As_double(obj2));
16289 if (SWIG_arg_fail(3)) SWIG_fail;
16290 }
16291 {
16292 PyThreadState* __tstate = wxPyBeginAllowThreads();
16293 (arg1)->SetUserScale(arg2,arg3);
16294
16295 wxPyEndAllowThreads(__tstate);
16296 if (PyErr_Occurred()) SWIG_fail;
16297 }
16298 Py_INCREF(Py_None); resultobj = Py_None;
16299 return resultobj;
16300 fail:
16301 return NULL;
16302 }
16303
16304
16305 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16306 PyObject *resultobj;
16307 wxDC *arg1 = (wxDC *) 0 ;
16308 double *arg2 = (double *) 0 ;
16309 double *arg3 = (double *) 0 ;
16310 double temp2 ;
16311 int res2 = 0 ;
16312 double temp3 ;
16313 int res3 = 0 ;
16314 PyObject * obj0 = 0 ;
16315 char *kwnames[] = {
16316 (char *) "self", NULL
16317 };
16318
16319 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16320 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16323 if (SWIG_arg_fail(1)) SWIG_fail;
16324 {
16325 PyThreadState* __tstate = wxPyBeginAllowThreads();
16326 (arg1)->GetLogicalScale(arg2,arg3);
16327
16328 wxPyEndAllowThreads(__tstate);
16329 if (PyErr_Occurred()) SWIG_fail;
16330 }
16331 Py_INCREF(Py_None); resultobj = Py_None;
16332 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16333 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16334 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16335 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16336 return resultobj;
16337 fail:
16338 return NULL;
16339 }
16340
16341
16342 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16343 PyObject *resultobj;
16344 wxDC *arg1 = (wxDC *) 0 ;
16345 double arg2 ;
16346 double arg3 ;
16347 PyObject * obj0 = 0 ;
16348 PyObject * obj1 = 0 ;
16349 PyObject * obj2 = 0 ;
16350 char *kwnames[] = {
16351 (char *) "self",(char *) "x",(char *) "y", NULL
16352 };
16353
16354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16356 if (SWIG_arg_fail(1)) SWIG_fail;
16357 {
16358 arg2 = (double)(SWIG_As_double(obj1));
16359 if (SWIG_arg_fail(2)) SWIG_fail;
16360 }
16361 {
16362 arg3 = (double)(SWIG_As_double(obj2));
16363 if (SWIG_arg_fail(3)) SWIG_fail;
16364 }
16365 {
16366 PyThreadState* __tstate = wxPyBeginAllowThreads();
16367 (arg1)->SetLogicalScale(arg2,arg3);
16368
16369 wxPyEndAllowThreads(__tstate);
16370 if (PyErr_Occurred()) SWIG_fail;
16371 }
16372 Py_INCREF(Py_None); resultobj = Py_None;
16373 return resultobj;
16374 fail:
16375 return NULL;
16376 }
16377
16378
16379 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16380 PyObject *resultobj;
16381 wxDC *arg1 = (wxDC *) 0 ;
16382 wxPoint result;
16383 PyObject * obj0 = 0 ;
16384 char *kwnames[] = {
16385 (char *) "self", NULL
16386 };
16387
16388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16390 if (SWIG_arg_fail(1)) SWIG_fail;
16391 {
16392 PyThreadState* __tstate = wxPyBeginAllowThreads();
16393 result = ((wxDC const *)arg1)->GetLogicalOrigin();
16394
16395 wxPyEndAllowThreads(__tstate);
16396 if (PyErr_Occurred()) SWIG_fail;
16397 }
16398 {
16399 wxPoint * resultptr;
16400 resultptr = new wxPoint((wxPoint &)(result));
16401 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16402 }
16403 return resultobj;
16404 fail:
16405 return NULL;
16406 }
16407
16408
16409 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16410 PyObject *resultobj;
16411 wxDC *arg1 = (wxDC *) 0 ;
16412 int *arg2 = (int *) 0 ;
16413 int *arg3 = (int *) 0 ;
16414 int temp2 ;
16415 int res2 = 0 ;
16416 int temp3 ;
16417 int res3 = 0 ;
16418 PyObject * obj0 = 0 ;
16419 char *kwnames[] = {
16420 (char *) "self", NULL
16421 };
16422
16423 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16424 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
16426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16427 if (SWIG_arg_fail(1)) SWIG_fail;
16428 {
16429 PyThreadState* __tstate = wxPyBeginAllowThreads();
16430 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
16431
16432 wxPyEndAllowThreads(__tstate);
16433 if (PyErr_Occurred()) SWIG_fail;
16434 }
16435 Py_INCREF(Py_None); resultobj = Py_None;
16436 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16437 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16438 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16439 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16440 return resultobj;
16441 fail:
16442 return NULL;
16443 }
16444
16445
16446 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16447 PyObject *resultobj;
16448 wxDC *arg1 = (wxDC *) 0 ;
16449 int arg2 ;
16450 int arg3 ;
16451 PyObject * obj0 = 0 ;
16452 PyObject * obj1 = 0 ;
16453 PyObject * obj2 = 0 ;
16454 char *kwnames[] = {
16455 (char *) "self",(char *) "x",(char *) "y", NULL
16456 };
16457
16458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16460 if (SWIG_arg_fail(1)) SWIG_fail;
16461 {
16462 arg2 = (int)(SWIG_As_int(obj1));
16463 if (SWIG_arg_fail(2)) SWIG_fail;
16464 }
16465 {
16466 arg3 = (int)(SWIG_As_int(obj2));
16467 if (SWIG_arg_fail(3)) SWIG_fail;
16468 }
16469 {
16470 PyThreadState* __tstate = wxPyBeginAllowThreads();
16471 (arg1)->SetLogicalOrigin(arg2,arg3);
16472
16473 wxPyEndAllowThreads(__tstate);
16474 if (PyErr_Occurred()) SWIG_fail;
16475 }
16476 Py_INCREF(Py_None); resultobj = Py_None;
16477 return resultobj;
16478 fail:
16479 return NULL;
16480 }
16481
16482
16483 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16484 PyObject *resultobj;
16485 wxDC *arg1 = (wxDC *) 0 ;
16486 wxPoint *arg2 = 0 ;
16487 wxPoint temp2 ;
16488 PyObject * obj0 = 0 ;
16489 PyObject * obj1 = 0 ;
16490 char *kwnames[] = {
16491 (char *) "self",(char *) "point", NULL
16492 };
16493
16494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16496 if (SWIG_arg_fail(1)) SWIG_fail;
16497 {
16498 arg2 = &temp2;
16499 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16500 }
16501 {
16502 PyThreadState* __tstate = wxPyBeginAllowThreads();
16503 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
16504
16505 wxPyEndAllowThreads(__tstate);
16506 if (PyErr_Occurred()) SWIG_fail;
16507 }
16508 Py_INCREF(Py_None); resultobj = Py_None;
16509 return resultobj;
16510 fail:
16511 return NULL;
16512 }
16513
16514
16515 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16516 PyObject *resultobj;
16517 wxDC *arg1 = (wxDC *) 0 ;
16518 wxPoint result;
16519 PyObject * obj0 = 0 ;
16520 char *kwnames[] = {
16521 (char *) "self", NULL
16522 };
16523
16524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
16525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16526 if (SWIG_arg_fail(1)) SWIG_fail;
16527 {
16528 PyThreadState* __tstate = wxPyBeginAllowThreads();
16529 result = ((wxDC const *)arg1)->GetDeviceOrigin();
16530
16531 wxPyEndAllowThreads(__tstate);
16532 if (PyErr_Occurred()) SWIG_fail;
16533 }
16534 {
16535 wxPoint * resultptr;
16536 resultptr = new wxPoint((wxPoint &)(result));
16537 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16538 }
16539 return resultobj;
16540 fail:
16541 return NULL;
16542 }
16543
16544
16545 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16546 PyObject *resultobj;
16547 wxDC *arg1 = (wxDC *) 0 ;
16548 int *arg2 = (int *) 0 ;
16549 int *arg3 = (int *) 0 ;
16550 int temp2 ;
16551 int res2 = 0 ;
16552 int temp3 ;
16553 int res3 = 0 ;
16554 PyObject * obj0 = 0 ;
16555 char *kwnames[] = {
16556 (char *) "self", NULL
16557 };
16558
16559 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16560 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
16562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16563 if (SWIG_arg_fail(1)) SWIG_fail;
16564 {
16565 PyThreadState* __tstate = wxPyBeginAllowThreads();
16566 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
16567
16568 wxPyEndAllowThreads(__tstate);
16569 if (PyErr_Occurred()) SWIG_fail;
16570 }
16571 Py_INCREF(Py_None); resultobj = Py_None;
16572 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16573 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16574 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16575 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16576 return resultobj;
16577 fail:
16578 return NULL;
16579 }
16580
16581
16582 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16583 PyObject *resultobj;
16584 wxDC *arg1 = (wxDC *) 0 ;
16585 int arg2 ;
16586 int arg3 ;
16587 PyObject * obj0 = 0 ;
16588 PyObject * obj1 = 0 ;
16589 PyObject * obj2 = 0 ;
16590 char *kwnames[] = {
16591 (char *) "self",(char *) "x",(char *) "y", NULL
16592 };
16593
16594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16596 if (SWIG_arg_fail(1)) SWIG_fail;
16597 {
16598 arg2 = (int)(SWIG_As_int(obj1));
16599 if (SWIG_arg_fail(2)) SWIG_fail;
16600 }
16601 {
16602 arg3 = (int)(SWIG_As_int(obj2));
16603 if (SWIG_arg_fail(3)) SWIG_fail;
16604 }
16605 {
16606 PyThreadState* __tstate = wxPyBeginAllowThreads();
16607 (arg1)->SetDeviceOrigin(arg2,arg3);
16608
16609 wxPyEndAllowThreads(__tstate);
16610 if (PyErr_Occurred()) SWIG_fail;
16611 }
16612 Py_INCREF(Py_None); resultobj = Py_None;
16613 return resultobj;
16614 fail:
16615 return NULL;
16616 }
16617
16618
16619 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16620 PyObject *resultobj;
16621 wxDC *arg1 = (wxDC *) 0 ;
16622 wxPoint *arg2 = 0 ;
16623 wxPoint temp2 ;
16624 PyObject * obj0 = 0 ;
16625 PyObject * obj1 = 0 ;
16626 char *kwnames[] = {
16627 (char *) "self",(char *) "point", NULL
16628 };
16629
16630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16632 if (SWIG_arg_fail(1)) SWIG_fail;
16633 {
16634 arg2 = &temp2;
16635 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16636 }
16637 {
16638 PyThreadState* __tstate = wxPyBeginAllowThreads();
16639 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
16640
16641 wxPyEndAllowThreads(__tstate);
16642 if (PyErr_Occurred()) SWIG_fail;
16643 }
16644 Py_INCREF(Py_None); resultobj = Py_None;
16645 return resultobj;
16646 fail:
16647 return NULL;
16648 }
16649
16650
16651 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16652 PyObject *resultobj;
16653 wxDC *arg1 = (wxDC *) 0 ;
16654 bool arg2 ;
16655 bool arg3 ;
16656 PyObject * obj0 = 0 ;
16657 PyObject * obj1 = 0 ;
16658 PyObject * obj2 = 0 ;
16659 char *kwnames[] = {
16660 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
16661 };
16662
16663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
16664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16665 if (SWIG_arg_fail(1)) SWIG_fail;
16666 {
16667 arg2 = (bool)(SWIG_As_bool(obj1));
16668 if (SWIG_arg_fail(2)) SWIG_fail;
16669 }
16670 {
16671 arg3 = (bool)(SWIG_As_bool(obj2));
16672 if (SWIG_arg_fail(3)) SWIG_fail;
16673 }
16674 {
16675 PyThreadState* __tstate = wxPyBeginAllowThreads();
16676 (arg1)->SetAxisOrientation(arg2,arg3);
16677
16678 wxPyEndAllowThreads(__tstate);
16679 if (PyErr_Occurred()) SWIG_fail;
16680 }
16681 Py_INCREF(Py_None); resultobj = Py_None;
16682 return resultobj;
16683 fail:
16684 return NULL;
16685 }
16686
16687
16688 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16689 PyObject *resultobj;
16690 wxDC *arg1 = (wxDC *) 0 ;
16691 int result;
16692 PyObject * obj0 = 0 ;
16693 char *kwnames[] = {
16694 (char *) "self", NULL
16695 };
16696
16697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
16698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16699 if (SWIG_arg_fail(1)) SWIG_fail;
16700 {
16701 PyThreadState* __tstate = wxPyBeginAllowThreads();
16702 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
16703
16704 wxPyEndAllowThreads(__tstate);
16705 if (PyErr_Occurred()) SWIG_fail;
16706 }
16707 {
16708 resultobj = SWIG_From_int((int)(result));
16709 }
16710 return resultobj;
16711 fail:
16712 return NULL;
16713 }
16714
16715
16716 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16717 PyObject *resultobj;
16718 wxDC *arg1 = (wxDC *) 0 ;
16719 int arg2 ;
16720 PyObject * obj0 = 0 ;
16721 PyObject * obj1 = 0 ;
16722 char *kwnames[] = {
16723 (char *) "self",(char *) "function", NULL
16724 };
16725
16726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
16727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16728 if (SWIG_arg_fail(1)) SWIG_fail;
16729 {
16730 arg2 = (int)(SWIG_As_int(obj1));
16731 if (SWIG_arg_fail(2)) SWIG_fail;
16732 }
16733 {
16734 PyThreadState* __tstate = wxPyBeginAllowThreads();
16735 (arg1)->SetLogicalFunction(arg2);
16736
16737 wxPyEndAllowThreads(__tstate);
16738 if (PyErr_Occurred()) SWIG_fail;
16739 }
16740 Py_INCREF(Py_None); resultobj = Py_None;
16741 return resultobj;
16742 fail:
16743 return NULL;
16744 }
16745
16746
16747 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16748 PyObject *resultobj;
16749 wxDC *arg1 = (wxDC *) 0 ;
16750 PyObject * obj0 = 0 ;
16751 char *kwnames[] = {
16752 (char *) "self", NULL
16753 };
16754
16755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
16756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16757 if (SWIG_arg_fail(1)) SWIG_fail;
16758 {
16759 PyThreadState* __tstate = wxPyBeginAllowThreads();
16760 (arg1)->ComputeScaleAndOrigin();
16761
16762 wxPyEndAllowThreads(__tstate);
16763 if (PyErr_Occurred()) SWIG_fail;
16764 }
16765 Py_INCREF(Py_None); resultobj = Py_None;
16766 return resultobj;
16767 fail:
16768 return NULL;
16769 }
16770
16771
16772 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16773 PyObject *resultobj;
16774 wxDC *arg1 = (wxDC *) 0 ;
16775 int arg2 ;
16776 int arg3 ;
16777 PyObject * obj0 = 0 ;
16778 PyObject * obj1 = 0 ;
16779 PyObject * obj2 = 0 ;
16780 char *kwnames[] = {
16781 (char *) "self",(char *) "x",(char *) "y", NULL
16782 };
16783
16784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
16785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16786 if (SWIG_arg_fail(1)) SWIG_fail;
16787 {
16788 arg2 = (int)(SWIG_As_int(obj1));
16789 if (SWIG_arg_fail(2)) SWIG_fail;
16790 }
16791 {
16792 arg3 = (int)(SWIG_As_int(obj2));
16793 if (SWIG_arg_fail(3)) SWIG_fail;
16794 }
16795 {
16796 PyThreadState* __tstate = wxPyBeginAllowThreads();
16797 (arg1)->CalcBoundingBox(arg2,arg3);
16798
16799 wxPyEndAllowThreads(__tstate);
16800 if (PyErr_Occurred()) SWIG_fail;
16801 }
16802 Py_INCREF(Py_None); resultobj = Py_None;
16803 return resultobj;
16804 fail:
16805 return NULL;
16806 }
16807
16808
16809 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16810 PyObject *resultobj;
16811 wxDC *arg1 = (wxDC *) 0 ;
16812 wxPoint *arg2 = 0 ;
16813 wxPoint temp2 ;
16814 PyObject * obj0 = 0 ;
16815 PyObject * obj1 = 0 ;
16816 char *kwnames[] = {
16817 (char *) "self",(char *) "point", NULL
16818 };
16819
16820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
16821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16822 if (SWIG_arg_fail(1)) SWIG_fail;
16823 {
16824 arg2 = &temp2;
16825 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16826 }
16827 {
16828 PyThreadState* __tstate = wxPyBeginAllowThreads();
16829 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
16830
16831 wxPyEndAllowThreads(__tstate);
16832 if (PyErr_Occurred()) SWIG_fail;
16833 }
16834 Py_INCREF(Py_None); resultobj = Py_None;
16835 return resultobj;
16836 fail:
16837 return NULL;
16838 }
16839
16840
16841 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16842 PyObject *resultobj;
16843 wxDC *arg1 = (wxDC *) 0 ;
16844 PyObject * obj0 = 0 ;
16845 char *kwnames[] = {
16846 (char *) "self", NULL
16847 };
16848
16849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
16850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16851 if (SWIG_arg_fail(1)) SWIG_fail;
16852 {
16853 PyThreadState* __tstate = wxPyBeginAllowThreads();
16854 (arg1)->ResetBoundingBox();
16855
16856 wxPyEndAllowThreads(__tstate);
16857 if (PyErr_Occurred()) SWIG_fail;
16858 }
16859 Py_INCREF(Py_None); resultobj = Py_None;
16860 return resultobj;
16861 fail:
16862 return NULL;
16863 }
16864
16865
16866 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
16867 PyObject *resultobj;
16868 wxDC *arg1 = (wxDC *) 0 ;
16869 int result;
16870 PyObject * obj0 = 0 ;
16871 char *kwnames[] = {
16872 (char *) "self", NULL
16873 };
16874
16875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
16876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16877 if (SWIG_arg_fail(1)) SWIG_fail;
16878 {
16879 PyThreadState* __tstate = wxPyBeginAllowThreads();
16880 result = (int)((wxDC const *)arg1)->MinX();
16881
16882 wxPyEndAllowThreads(__tstate);
16883 if (PyErr_Occurred()) SWIG_fail;
16884 }
16885 {
16886 resultobj = SWIG_From_int((int)(result));
16887 }
16888 return resultobj;
16889 fail:
16890 return NULL;
16891 }
16892
16893
16894 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
16895 PyObject *resultobj;
16896 wxDC *arg1 = (wxDC *) 0 ;
16897 int result;
16898 PyObject * obj0 = 0 ;
16899 char *kwnames[] = {
16900 (char *) "self", NULL
16901 };
16902
16903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
16904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16905 if (SWIG_arg_fail(1)) SWIG_fail;
16906 {
16907 PyThreadState* __tstate = wxPyBeginAllowThreads();
16908 result = (int)((wxDC const *)arg1)->MaxX();
16909
16910 wxPyEndAllowThreads(__tstate);
16911 if (PyErr_Occurred()) SWIG_fail;
16912 }
16913 {
16914 resultobj = SWIG_From_int((int)(result));
16915 }
16916 return resultobj;
16917 fail:
16918 return NULL;
16919 }
16920
16921
16922 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
16923 PyObject *resultobj;
16924 wxDC *arg1 = (wxDC *) 0 ;
16925 int result;
16926 PyObject * obj0 = 0 ;
16927 char *kwnames[] = {
16928 (char *) "self", NULL
16929 };
16930
16931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
16932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16933 if (SWIG_arg_fail(1)) SWIG_fail;
16934 {
16935 PyThreadState* __tstate = wxPyBeginAllowThreads();
16936 result = (int)((wxDC const *)arg1)->MinY();
16937
16938 wxPyEndAllowThreads(__tstate);
16939 if (PyErr_Occurred()) SWIG_fail;
16940 }
16941 {
16942 resultobj = SWIG_From_int((int)(result));
16943 }
16944 return resultobj;
16945 fail:
16946 return NULL;
16947 }
16948
16949
16950 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
16951 PyObject *resultobj;
16952 wxDC *arg1 = (wxDC *) 0 ;
16953 int result;
16954 PyObject * obj0 = 0 ;
16955 char *kwnames[] = {
16956 (char *) "self", NULL
16957 };
16958
16959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
16960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16961 if (SWIG_arg_fail(1)) SWIG_fail;
16962 {
16963 PyThreadState* __tstate = wxPyBeginAllowThreads();
16964 result = (int)((wxDC const *)arg1)->MaxY();
16965
16966 wxPyEndAllowThreads(__tstate);
16967 if (PyErr_Occurred()) SWIG_fail;
16968 }
16969 {
16970 resultobj = SWIG_From_int((int)(result));
16971 }
16972 return resultobj;
16973 fail:
16974 return NULL;
16975 }
16976
16977
16978 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16979 PyObject *resultobj;
16980 wxDC *arg1 = (wxDC *) 0 ;
16981 int *arg2 = (int *) 0 ;
16982 int *arg3 = (int *) 0 ;
16983 int *arg4 = (int *) 0 ;
16984 int *arg5 = (int *) 0 ;
16985 int temp2 ;
16986 int res2 = 0 ;
16987 int temp3 ;
16988 int res3 = 0 ;
16989 int temp4 ;
16990 int res4 = 0 ;
16991 int temp5 ;
16992 int res5 = 0 ;
16993 PyObject * obj0 = 0 ;
16994 char *kwnames[] = {
16995 (char *) "self", NULL
16996 };
16997
16998 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16999 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17000 arg4 = &temp4; res4 = SWIG_NEWOBJ;
17001 arg5 = &temp5; res5 = SWIG_NEWOBJ;
17002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
17003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17004 if (SWIG_arg_fail(1)) SWIG_fail;
17005 {
17006 PyThreadState* __tstate = wxPyBeginAllowThreads();
17007 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
17008
17009 wxPyEndAllowThreads(__tstate);
17010 if (PyErr_Occurred()) SWIG_fail;
17011 }
17012 Py_INCREF(Py_None); resultobj = Py_None;
17013 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17014 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17015 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17016 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17017 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
17018 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
17019 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
17020 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
17021 return resultobj;
17022 fail:
17023 return NULL;
17024 }
17025
17026
17027 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
17028 PyObject *resultobj;
17029 wxDC *arg1 = (wxDC *) 0 ;
17030 PyObject *arg2 = (PyObject *) 0 ;
17031 PyObject *arg3 = (PyObject *) 0 ;
17032 PyObject *arg4 = (PyObject *) 0 ;
17033 PyObject *result;
17034 PyObject * obj0 = 0 ;
17035 PyObject * obj1 = 0 ;
17036 PyObject * obj2 = 0 ;
17037 PyObject * obj3 = 0 ;
17038 char *kwnames[] = {
17039 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17040 };
17041
17042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17044 if (SWIG_arg_fail(1)) SWIG_fail;
17045 arg2 = obj1;
17046 arg3 = obj2;
17047 arg4 = obj3;
17048 {
17049 PyThreadState* __tstate = wxPyBeginAllowThreads();
17050 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
17051
17052 wxPyEndAllowThreads(__tstate);
17053 if (PyErr_Occurred()) SWIG_fail;
17054 }
17055 resultobj = result;
17056 return resultobj;
17057 fail:
17058 return NULL;
17059 }
17060
17061
17062 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
17063 PyObject *resultobj;
17064 wxDC *arg1 = (wxDC *) 0 ;
17065 PyObject *arg2 = (PyObject *) 0 ;
17066 PyObject *arg3 = (PyObject *) 0 ;
17067 PyObject *arg4 = (PyObject *) 0 ;
17068 PyObject *result;
17069 PyObject * obj0 = 0 ;
17070 PyObject * obj1 = 0 ;
17071 PyObject * obj2 = 0 ;
17072 PyObject * obj3 = 0 ;
17073 char *kwnames[] = {
17074 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17075 };
17076
17077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17079 if (SWIG_arg_fail(1)) SWIG_fail;
17080 arg2 = obj1;
17081 arg3 = obj2;
17082 arg4 = obj3;
17083 {
17084 PyThreadState* __tstate = wxPyBeginAllowThreads();
17085 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
17086
17087 wxPyEndAllowThreads(__tstate);
17088 if (PyErr_Occurred()) SWIG_fail;
17089 }
17090 resultobj = result;
17091 return resultobj;
17092 fail:
17093 return NULL;
17094 }
17095
17096
17097 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
17098 PyObject *resultobj;
17099 wxDC *arg1 = (wxDC *) 0 ;
17100 PyObject *arg2 = (PyObject *) 0 ;
17101 PyObject *arg3 = (PyObject *) 0 ;
17102 PyObject *arg4 = (PyObject *) 0 ;
17103 PyObject *result;
17104 PyObject * obj0 = 0 ;
17105 PyObject * obj1 = 0 ;
17106 PyObject * obj2 = 0 ;
17107 PyObject * obj3 = 0 ;
17108 char *kwnames[] = {
17109 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17110 };
17111
17112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17114 if (SWIG_arg_fail(1)) SWIG_fail;
17115 arg2 = obj1;
17116 arg3 = obj2;
17117 arg4 = obj3;
17118 {
17119 PyThreadState* __tstate = wxPyBeginAllowThreads();
17120 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17121
17122 wxPyEndAllowThreads(__tstate);
17123 if (PyErr_Occurred()) SWIG_fail;
17124 }
17125 resultobj = result;
17126 return resultobj;
17127 fail:
17128 return NULL;
17129 }
17130
17131
17132 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17133 PyObject *resultobj;
17134 wxDC *arg1 = (wxDC *) 0 ;
17135 PyObject *arg2 = (PyObject *) 0 ;
17136 PyObject *arg3 = (PyObject *) 0 ;
17137 PyObject *arg4 = (PyObject *) 0 ;
17138 PyObject *result;
17139 PyObject * obj0 = 0 ;
17140 PyObject * obj1 = 0 ;
17141 PyObject * obj2 = 0 ;
17142 PyObject * obj3 = 0 ;
17143 char *kwnames[] = {
17144 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17145 };
17146
17147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17149 if (SWIG_arg_fail(1)) SWIG_fail;
17150 arg2 = obj1;
17151 arg3 = obj2;
17152 arg4 = obj3;
17153 {
17154 PyThreadState* __tstate = wxPyBeginAllowThreads();
17155 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17156
17157 wxPyEndAllowThreads(__tstate);
17158 if (PyErr_Occurred()) SWIG_fail;
17159 }
17160 resultobj = result;
17161 return resultobj;
17162 fail:
17163 return NULL;
17164 }
17165
17166
17167 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17168 PyObject *resultobj;
17169 wxDC *arg1 = (wxDC *) 0 ;
17170 PyObject *arg2 = (PyObject *) 0 ;
17171 PyObject *arg3 = (PyObject *) 0 ;
17172 PyObject *arg4 = (PyObject *) 0 ;
17173 PyObject *result;
17174 PyObject * obj0 = 0 ;
17175 PyObject * obj1 = 0 ;
17176 PyObject * obj2 = 0 ;
17177 PyObject * obj3 = 0 ;
17178 char *kwnames[] = {
17179 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17180 };
17181
17182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17184 if (SWIG_arg_fail(1)) SWIG_fail;
17185 arg2 = obj1;
17186 arg3 = obj2;
17187 arg4 = obj3;
17188 {
17189 PyThreadState* __tstate = wxPyBeginAllowThreads();
17190 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17191
17192 wxPyEndAllowThreads(__tstate);
17193 if (PyErr_Occurred()) SWIG_fail;
17194 }
17195 resultobj = result;
17196 return resultobj;
17197 fail:
17198 return NULL;
17199 }
17200
17201
17202 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17203 PyObject *resultobj;
17204 wxDC *arg1 = (wxDC *) 0 ;
17205 PyObject *arg2 = (PyObject *) 0 ;
17206 PyObject *arg3 = (PyObject *) 0 ;
17207 PyObject *arg4 = (PyObject *) 0 ;
17208 PyObject *arg5 = (PyObject *) 0 ;
17209 PyObject *result;
17210 PyObject * obj0 = 0 ;
17211 PyObject * obj1 = 0 ;
17212 PyObject * obj2 = 0 ;
17213 PyObject * obj3 = 0 ;
17214 PyObject * obj4 = 0 ;
17215 char *kwnames[] = {
17216 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17217 };
17218
17219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17221 if (SWIG_arg_fail(1)) SWIG_fail;
17222 arg2 = obj1;
17223 arg3 = obj2;
17224 arg4 = obj3;
17225 arg5 = obj4;
17226 {
17227 PyThreadState* __tstate = wxPyBeginAllowThreads();
17228 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17229
17230 wxPyEndAllowThreads(__tstate);
17231 if (PyErr_Occurred()) SWIG_fail;
17232 }
17233 resultobj = result;
17234 return resultobj;
17235 fail:
17236 return NULL;
17237 }
17238
17239
17240 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17241 PyObject *obj;
17242 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17243 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17244 Py_INCREF(obj);
17245 return Py_BuildValue((char *)"");
17246 }
17247 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17248 PyObject *resultobj;
17249 wxMemoryDC *result;
17250 char *kwnames[] = {
17251 NULL
17252 };
17253
17254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17255 {
17256 if (!wxPyCheckForApp()) SWIG_fail;
17257 PyThreadState* __tstate = wxPyBeginAllowThreads();
17258 result = (wxMemoryDC *)new wxMemoryDC();
17259
17260 wxPyEndAllowThreads(__tstate);
17261 if (PyErr_Occurred()) SWIG_fail;
17262 }
17263 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17264 return resultobj;
17265 fail:
17266 return NULL;
17267 }
17268
17269
17270 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17271 PyObject *resultobj;
17272 wxDC *arg1 = (wxDC *) 0 ;
17273 wxMemoryDC *result;
17274 PyObject * obj0 = 0 ;
17275 char *kwnames[] = {
17276 (char *) "oldDC", NULL
17277 };
17278
17279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17281 if (SWIG_arg_fail(1)) SWIG_fail;
17282 {
17283 if (!wxPyCheckForApp()) SWIG_fail;
17284 PyThreadState* __tstate = wxPyBeginAllowThreads();
17285 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17286
17287 wxPyEndAllowThreads(__tstate);
17288 if (PyErr_Occurred()) SWIG_fail;
17289 }
17290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17291 return resultobj;
17292 fail:
17293 return NULL;
17294 }
17295
17296
17297 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17298 PyObject *resultobj;
17299 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17300 wxBitmap *arg2 = 0 ;
17301 PyObject * obj0 = 0 ;
17302 PyObject * obj1 = 0 ;
17303 char *kwnames[] = {
17304 (char *) "self",(char *) "bitmap", NULL
17305 };
17306
17307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17309 if (SWIG_arg_fail(1)) SWIG_fail;
17310 {
17311 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17312 if (SWIG_arg_fail(2)) SWIG_fail;
17313 if (arg2 == NULL) {
17314 SWIG_null_ref("wxBitmap");
17315 }
17316 if (SWIG_arg_fail(2)) SWIG_fail;
17317 }
17318 {
17319 PyThreadState* __tstate = wxPyBeginAllowThreads();
17320 (arg1)->SelectObject((wxBitmap const &)*arg2);
17321
17322 wxPyEndAllowThreads(__tstate);
17323 if (PyErr_Occurred()) SWIG_fail;
17324 }
17325 Py_INCREF(Py_None); resultobj = Py_None;
17326 return resultobj;
17327 fail:
17328 return NULL;
17329 }
17330
17331
17332 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17333 PyObject *obj;
17334 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17335 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17336 Py_INCREF(obj);
17337 return Py_BuildValue((char *)"");
17338 }
17339 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17340 PyObject *resultobj;
17341 wxDC *arg1 = (wxDC *) 0 ;
17342 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17343 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17344 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17345 wxBufferedDC *result;
17346 PyObject * obj0 = 0 ;
17347 PyObject * obj1 = 0 ;
17348 PyObject * obj2 = 0 ;
17349
17350 if(!PyArg_ParseTuple(args,(char *)"O|OO:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17352 if (SWIG_arg_fail(1)) SWIG_fail;
17353 if (obj1) {
17354 {
17355 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17356 if (SWIG_arg_fail(2)) SWIG_fail;
17357 if (arg2 == NULL) {
17358 SWIG_null_ref("wxBitmap");
17359 }
17360 if (SWIG_arg_fail(2)) SWIG_fail;
17361 }
17362 }
17363 if (obj2) {
17364 {
17365 arg3 = (int)(SWIG_As_int(obj2));
17366 if (SWIG_arg_fail(3)) SWIG_fail;
17367 }
17368 }
17369 {
17370 if (!wxPyCheckForApp()) SWIG_fail;
17371 PyThreadState* __tstate = wxPyBeginAllowThreads();
17372 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
17373
17374 wxPyEndAllowThreads(__tstate);
17375 if (PyErr_Occurred()) SWIG_fail;
17376 }
17377 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17378 return resultobj;
17379 fail:
17380 return NULL;
17381 }
17382
17383
17384 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17385 PyObject *resultobj;
17386 wxDC *arg1 = (wxDC *) 0 ;
17387 wxSize *arg2 = 0 ;
17388 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17389 wxBufferedDC *result;
17390 wxSize temp2 ;
17391 PyObject * obj0 = 0 ;
17392 PyObject * obj1 = 0 ;
17393 PyObject * obj2 = 0 ;
17394
17395 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17397 if (SWIG_arg_fail(1)) SWIG_fail;
17398 {
17399 arg2 = &temp2;
17400 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17401 }
17402 if (obj2) {
17403 {
17404 arg3 = (int)(SWIG_As_int(obj2));
17405 if (SWIG_arg_fail(3)) SWIG_fail;
17406 }
17407 }
17408 {
17409 if (!wxPyCheckForApp()) SWIG_fail;
17410 PyThreadState* __tstate = wxPyBeginAllowThreads();
17411 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
17412
17413 wxPyEndAllowThreads(__tstate);
17414 if (PyErr_Occurred()) SWIG_fail;
17415 }
17416 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17417 return resultobj;
17418 fail:
17419 return NULL;
17420 }
17421
17422
17423 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
17424 int argc;
17425 PyObject *argv[4];
17426 int ii;
17427
17428 argc = PyObject_Length(args);
17429 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
17430 argv[ii] = PyTuple_GetItem(args,ii);
17431 }
17432 if ((argc >= 1) && (argc <= 3)) {
17433 int _v;
17434 {
17435 void *ptr;
17436 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17437 _v = 0;
17438 PyErr_Clear();
17439 } else {
17440 _v = 1;
17441 }
17442 }
17443 if (_v) {
17444 if (argc <= 1) {
17445 return _wrap_new_BufferedDC__SWIG_0(self,args);
17446 }
17447 {
17448 void *ptr = 0;
17449 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
17450 _v = 0;
17451 PyErr_Clear();
17452 } else {
17453 _v = (ptr != 0);
17454 }
17455 }
17456 if (_v) {
17457 if (argc <= 2) {
17458 return _wrap_new_BufferedDC__SWIG_0(self,args);
17459 }
17460 _v = SWIG_Check_int(argv[2]);
17461 if (_v) {
17462 return _wrap_new_BufferedDC__SWIG_0(self,args);
17463 }
17464 }
17465 }
17466 }
17467 if ((argc >= 2) && (argc <= 3)) {
17468 int _v;
17469 {
17470 void *ptr;
17471 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17472 _v = 0;
17473 PyErr_Clear();
17474 } else {
17475 _v = 1;
17476 }
17477 }
17478 if (_v) {
17479 {
17480 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
17481 }
17482 if (_v) {
17483 if (argc <= 2) {
17484 return _wrap_new_BufferedDC__SWIG_1(self,args);
17485 }
17486 _v = SWIG_Check_int(argv[2]);
17487 if (_v) {
17488 return _wrap_new_BufferedDC__SWIG_1(self,args);
17489 }
17490 }
17491 }
17492 }
17493
17494 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
17495 return NULL;
17496 }
17497
17498
17499 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
17500 PyObject *resultobj;
17501 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17502 PyObject * obj0 = 0 ;
17503 char *kwnames[] = {
17504 (char *) "self", NULL
17505 };
17506
17507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
17508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17509 if (SWIG_arg_fail(1)) SWIG_fail;
17510 {
17511 PyThreadState* __tstate = wxPyBeginAllowThreads();
17512 delete arg1;
17513
17514 wxPyEndAllowThreads(__tstate);
17515 if (PyErr_Occurred()) SWIG_fail;
17516 }
17517 Py_INCREF(Py_None); resultobj = Py_None;
17518 return resultobj;
17519 fail:
17520 return NULL;
17521 }
17522
17523
17524 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
17525 PyObject *resultobj;
17526 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17527 PyObject * obj0 = 0 ;
17528 char *kwnames[] = {
17529 (char *) "self", NULL
17530 };
17531
17532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
17533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17534 if (SWIG_arg_fail(1)) SWIG_fail;
17535 {
17536 PyThreadState* __tstate = wxPyBeginAllowThreads();
17537 (arg1)->UnMask();
17538
17539 wxPyEndAllowThreads(__tstate);
17540 if (PyErr_Occurred()) SWIG_fail;
17541 }
17542 Py_INCREF(Py_None); resultobj = Py_None;
17543 return resultobj;
17544 fail:
17545 return NULL;
17546 }
17547
17548
17549 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
17550 PyObject *obj;
17551 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17552 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
17553 Py_INCREF(obj);
17554 return Py_BuildValue((char *)"");
17555 }
17556 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17557 PyObject *resultobj;
17558 wxWindow *arg1 = (wxWindow *) 0 ;
17559 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17560 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17561 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17562 wxBufferedPaintDC *result;
17563 PyObject * obj0 = 0 ;
17564 PyObject * obj1 = 0 ;
17565 PyObject * obj2 = 0 ;
17566 char *kwnames[] = {
17567 (char *) "window",(char *) "buffer",(char *) "style", NULL
17568 };
17569
17570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
17571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17572 if (SWIG_arg_fail(1)) SWIG_fail;
17573 if (obj1) {
17574 {
17575 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17576 if (SWIG_arg_fail(2)) SWIG_fail;
17577 if (arg2 == NULL) {
17578 SWIG_null_ref("wxBitmap");
17579 }
17580 if (SWIG_arg_fail(2)) SWIG_fail;
17581 }
17582 }
17583 if (obj2) {
17584 {
17585 arg3 = (int)(SWIG_As_int(obj2));
17586 if (SWIG_arg_fail(3)) SWIG_fail;
17587 }
17588 }
17589 {
17590 if (!wxPyCheckForApp()) SWIG_fail;
17591 PyThreadState* __tstate = wxPyBeginAllowThreads();
17592 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
17593
17594 wxPyEndAllowThreads(__tstate);
17595 if (PyErr_Occurred()) SWIG_fail;
17596 }
17597 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
17598 return resultobj;
17599 fail:
17600 return NULL;
17601 }
17602
17603
17604 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
17605 PyObject *obj;
17606 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17607 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
17608 Py_INCREF(obj);
17609 return Py_BuildValue((char *)"");
17610 }
17611 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
17612 PyObject *resultobj;
17613 wxScreenDC *result;
17614 char *kwnames[] = {
17615 NULL
17616 };
17617
17618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
17619 {
17620 if (!wxPyCheckForApp()) SWIG_fail;
17621 PyThreadState* __tstate = wxPyBeginAllowThreads();
17622 result = (wxScreenDC *)new wxScreenDC();
17623
17624 wxPyEndAllowThreads(__tstate);
17625 if (PyErr_Occurred()) SWIG_fail;
17626 }
17627 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
17628 return resultobj;
17629 fail:
17630 return NULL;
17631 }
17632
17633
17634 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
17635 PyObject *resultobj;
17636 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17637 wxWindow *arg2 = (wxWindow *) 0 ;
17638 bool result;
17639 PyObject * obj0 = 0 ;
17640 PyObject * obj1 = 0 ;
17641 char *kwnames[] = {
17642 (char *) "self",(char *) "window", NULL
17643 };
17644
17645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
17646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17647 if (SWIG_arg_fail(1)) SWIG_fail;
17648 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17649 if (SWIG_arg_fail(2)) SWIG_fail;
17650 {
17651 PyThreadState* __tstate = wxPyBeginAllowThreads();
17652 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17653
17654 wxPyEndAllowThreads(__tstate);
17655 if (PyErr_Occurred()) SWIG_fail;
17656 }
17657 {
17658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17659 }
17660 return resultobj;
17661 fail:
17662 return NULL;
17663 }
17664
17665
17666 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17667 PyObject *resultobj;
17668 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17669 wxRect *arg2 = (wxRect *) NULL ;
17670 bool result;
17671 PyObject * obj0 = 0 ;
17672 PyObject * obj1 = 0 ;
17673 char *kwnames[] = {
17674 (char *) "self",(char *) "rect", NULL
17675 };
17676
17677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
17678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17679 if (SWIG_arg_fail(1)) SWIG_fail;
17680 if (obj1) {
17681 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
17682 if (SWIG_arg_fail(2)) SWIG_fail;
17683 }
17684 {
17685 PyThreadState* __tstate = wxPyBeginAllowThreads();
17686 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17687
17688 wxPyEndAllowThreads(__tstate);
17689 if (PyErr_Occurred()) SWIG_fail;
17690 }
17691 {
17692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17693 }
17694 return resultobj;
17695 fail:
17696 return NULL;
17697 }
17698
17699
17700 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17701 PyObject *resultobj;
17702 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17703 bool result;
17704 PyObject * obj0 = 0 ;
17705 char *kwnames[] = {
17706 (char *) "self", NULL
17707 };
17708
17709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
17710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17711 if (SWIG_arg_fail(1)) SWIG_fail;
17712 {
17713 PyThreadState* __tstate = wxPyBeginAllowThreads();
17714 result = (bool)(arg1)->EndDrawingOnTop();
17715
17716 wxPyEndAllowThreads(__tstate);
17717 if (PyErr_Occurred()) SWIG_fail;
17718 }
17719 {
17720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17721 }
17722 return resultobj;
17723 fail:
17724 return NULL;
17725 }
17726
17727
17728 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
17729 PyObject *obj;
17730 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17731 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
17732 Py_INCREF(obj);
17733 return Py_BuildValue((char *)"");
17734 }
17735 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
17736 PyObject *resultobj;
17737 wxWindow *arg1 = (wxWindow *) 0 ;
17738 wxClientDC *result;
17739 PyObject * obj0 = 0 ;
17740 char *kwnames[] = {
17741 (char *) "win", NULL
17742 };
17743
17744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
17745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17746 if (SWIG_arg_fail(1)) SWIG_fail;
17747 {
17748 if (!wxPyCheckForApp()) SWIG_fail;
17749 PyThreadState* __tstate = wxPyBeginAllowThreads();
17750 result = (wxClientDC *)new wxClientDC(arg1);
17751
17752 wxPyEndAllowThreads(__tstate);
17753 if (PyErr_Occurred()) SWIG_fail;
17754 }
17755 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
17756 return resultobj;
17757 fail:
17758 return NULL;
17759 }
17760
17761
17762 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
17763 PyObject *obj;
17764 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17765 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
17766 Py_INCREF(obj);
17767 return Py_BuildValue((char *)"");
17768 }
17769 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17770 PyObject *resultobj;
17771 wxWindow *arg1 = (wxWindow *) 0 ;
17772 wxPaintDC *result;
17773 PyObject * obj0 = 0 ;
17774 char *kwnames[] = {
17775 (char *) "win", NULL
17776 };
17777
17778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
17779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17780 if (SWIG_arg_fail(1)) SWIG_fail;
17781 {
17782 if (!wxPyCheckForApp()) SWIG_fail;
17783 PyThreadState* __tstate = wxPyBeginAllowThreads();
17784 result = (wxPaintDC *)new wxPaintDC(arg1);
17785
17786 wxPyEndAllowThreads(__tstate);
17787 if (PyErr_Occurred()) SWIG_fail;
17788 }
17789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
17790 return resultobj;
17791 fail:
17792 return NULL;
17793 }
17794
17795
17796 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
17797 PyObject *obj;
17798 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17799 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
17800 Py_INCREF(obj);
17801 return Py_BuildValue((char *)"");
17802 }
17803 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
17804 PyObject *resultobj;
17805 wxWindow *arg1 = (wxWindow *) 0 ;
17806 wxWindowDC *result;
17807 PyObject * obj0 = 0 ;
17808 char *kwnames[] = {
17809 (char *) "win", NULL
17810 };
17811
17812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
17813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17814 if (SWIG_arg_fail(1)) SWIG_fail;
17815 {
17816 if (!wxPyCheckForApp()) SWIG_fail;
17817 PyThreadState* __tstate = wxPyBeginAllowThreads();
17818 result = (wxWindowDC *)new wxWindowDC(arg1);
17819
17820 wxPyEndAllowThreads(__tstate);
17821 if (PyErr_Occurred()) SWIG_fail;
17822 }
17823 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
17824 return resultobj;
17825 fail:
17826 return NULL;
17827 }
17828
17829
17830 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
17831 PyObject *obj;
17832 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17833 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
17834 Py_INCREF(obj);
17835 return Py_BuildValue((char *)"");
17836 }
17837 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
17838 PyObject *resultobj;
17839 wxDC *arg1 = 0 ;
17840 bool arg2 ;
17841 wxMirrorDC *result;
17842 PyObject * obj0 = 0 ;
17843 PyObject * obj1 = 0 ;
17844 char *kwnames[] = {
17845 (char *) "dc",(char *) "mirror", NULL
17846 };
17847
17848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
17849 {
17850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17851 if (SWIG_arg_fail(1)) SWIG_fail;
17852 if (arg1 == NULL) {
17853 SWIG_null_ref("wxDC");
17854 }
17855 if (SWIG_arg_fail(1)) SWIG_fail;
17856 }
17857 {
17858 arg2 = (bool)(SWIG_As_bool(obj1));
17859 if (SWIG_arg_fail(2)) SWIG_fail;
17860 }
17861 {
17862 if (!wxPyCheckForApp()) SWIG_fail;
17863 PyThreadState* __tstate = wxPyBeginAllowThreads();
17864 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
17865
17866 wxPyEndAllowThreads(__tstate);
17867 if (PyErr_Occurred()) SWIG_fail;
17868 }
17869 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
17870 return resultobj;
17871 fail:
17872 return NULL;
17873 }
17874
17875
17876 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
17877 PyObject *obj;
17878 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17879 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
17880 Py_INCREF(obj);
17881 return Py_BuildValue((char *)"");
17882 }
17883 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
17884 PyObject *resultobj;
17885 wxPrintData *arg1 = 0 ;
17886 wxPostScriptDC *result;
17887 PyObject * obj0 = 0 ;
17888 char *kwnames[] = {
17889 (char *) "printData", NULL
17890 };
17891
17892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
17893 {
17894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17895 if (SWIG_arg_fail(1)) SWIG_fail;
17896 if (arg1 == NULL) {
17897 SWIG_null_ref("wxPrintData");
17898 }
17899 if (SWIG_arg_fail(1)) SWIG_fail;
17900 }
17901 {
17902 if (!wxPyCheckForApp()) SWIG_fail;
17903 PyThreadState* __tstate = wxPyBeginAllowThreads();
17904 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
17905
17906 wxPyEndAllowThreads(__tstate);
17907 if (PyErr_Occurred()) SWIG_fail;
17908 }
17909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
17910 return resultobj;
17911 fail:
17912 return NULL;
17913 }
17914
17915
17916 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17917 PyObject *resultobj;
17918 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17919 wxPrintData *result;
17920 PyObject * obj0 = 0 ;
17921 char *kwnames[] = {
17922 (char *) "self", NULL
17923 };
17924
17925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
17926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17927 if (SWIG_arg_fail(1)) SWIG_fail;
17928 {
17929 PyThreadState* __tstate = wxPyBeginAllowThreads();
17930 {
17931 wxPrintData &_result_ref = (arg1)->GetPrintData();
17932 result = (wxPrintData *) &_result_ref;
17933 }
17934
17935 wxPyEndAllowThreads(__tstate);
17936 if (PyErr_Occurred()) SWIG_fail;
17937 }
17938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
17939 return resultobj;
17940 fail:
17941 return NULL;
17942 }
17943
17944
17945 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17946 PyObject *resultobj;
17947 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17948 wxPrintData *arg2 = 0 ;
17949 PyObject * obj0 = 0 ;
17950 PyObject * obj1 = 0 ;
17951 char *kwnames[] = {
17952 (char *) "self",(char *) "data", NULL
17953 };
17954
17955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
17956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17957 if (SWIG_arg_fail(1)) SWIG_fail;
17958 {
17959 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17960 if (SWIG_arg_fail(2)) SWIG_fail;
17961 if (arg2 == NULL) {
17962 SWIG_null_ref("wxPrintData");
17963 }
17964 if (SWIG_arg_fail(2)) SWIG_fail;
17965 }
17966 {
17967 PyThreadState* __tstate = wxPyBeginAllowThreads();
17968 (arg1)->SetPrintData((wxPrintData const &)*arg2);
17969
17970 wxPyEndAllowThreads(__tstate);
17971 if (PyErr_Occurred()) SWIG_fail;
17972 }
17973 Py_INCREF(Py_None); resultobj = Py_None;
17974 return resultobj;
17975 fail:
17976 return NULL;
17977 }
17978
17979
17980 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17981 PyObject *resultobj;
17982 int arg1 ;
17983 PyObject * obj0 = 0 ;
17984 char *kwnames[] = {
17985 (char *) "ppi", NULL
17986 };
17987
17988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
17989 {
17990 arg1 = (int)(SWIG_As_int(obj0));
17991 if (SWIG_arg_fail(1)) SWIG_fail;
17992 }
17993 {
17994 PyThreadState* __tstate = wxPyBeginAllowThreads();
17995 wxPostScriptDC::SetResolution(arg1);
17996
17997 wxPyEndAllowThreads(__tstate);
17998 if (PyErr_Occurred()) SWIG_fail;
17999 }
18000 Py_INCREF(Py_None); resultobj = Py_None;
18001 return resultobj;
18002 fail:
18003 return NULL;
18004 }
18005
18006
18007 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
18008 PyObject *resultobj;
18009 int result;
18010 char *kwnames[] = {
18011 NULL
18012 };
18013
18014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
18015 {
18016 PyThreadState* __tstate = wxPyBeginAllowThreads();
18017 result = (int)wxPostScriptDC::GetResolution();
18018
18019 wxPyEndAllowThreads(__tstate);
18020 if (PyErr_Occurred()) SWIG_fail;
18021 }
18022 {
18023 resultobj = SWIG_From_int((int)(result));
18024 }
18025 return resultobj;
18026 fail:
18027 return NULL;
18028 }
18029
18030
18031 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
18032 PyObject *obj;
18033 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18034 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
18035 Py_INCREF(obj);
18036 return Py_BuildValue((char *)"");
18037 }
18038 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18039 PyObject *resultobj;
18040 wxString const &arg1_defvalue = wxPyEmptyString ;
18041 wxString *arg1 = (wxString *) &arg1_defvalue ;
18042 wxMetaFile *result;
18043 bool temp1 = false ;
18044 PyObject * obj0 = 0 ;
18045 char *kwnames[] = {
18046 (char *) "filename", NULL
18047 };
18048
18049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
18050 if (obj0) {
18051 {
18052 arg1 = wxString_in_helper(obj0);
18053 if (arg1 == NULL) SWIG_fail;
18054 temp1 = true;
18055 }
18056 }
18057 {
18058 if (!wxPyCheckForApp()) SWIG_fail;
18059 PyThreadState* __tstate = wxPyBeginAllowThreads();
18060 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
18061
18062 wxPyEndAllowThreads(__tstate);
18063 if (PyErr_Occurred()) SWIG_fail;
18064 }
18065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
18066 {
18067 if (temp1)
18068 delete arg1;
18069 }
18070 return resultobj;
18071 fail:
18072 {
18073 if (temp1)
18074 delete arg1;
18075 }
18076 return NULL;
18077 }
18078
18079
18080 static PyObject *_wrap_delete_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18081 PyObject *resultobj;
18082 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18083 PyObject * obj0 = 0 ;
18084 char *kwnames[] = {
18085 (char *) "self", NULL
18086 };
18087
18088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MetaFile",kwnames,&obj0)) goto fail;
18089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18090 if (SWIG_arg_fail(1)) SWIG_fail;
18091 {
18092 PyThreadState* __tstate = wxPyBeginAllowThreads();
18093 delete arg1;
18094
18095 wxPyEndAllowThreads(__tstate);
18096 if (PyErr_Occurred()) SWIG_fail;
18097 }
18098 Py_INCREF(Py_None); resultobj = Py_None;
18099 return resultobj;
18100 fail:
18101 return NULL;
18102 }
18103
18104
18105 static PyObject *_wrap_MetaFile_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
18106 PyObject *resultobj;
18107 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18108 bool result;
18109 PyObject * obj0 = 0 ;
18110 char *kwnames[] = {
18111 (char *) "self", NULL
18112 };
18113
18114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_Ok",kwnames,&obj0)) goto fail;
18115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18116 if (SWIG_arg_fail(1)) SWIG_fail;
18117 {
18118 PyThreadState* __tstate = wxPyBeginAllowThreads();
18119 result = (bool)(arg1)->Ok();
18120
18121 wxPyEndAllowThreads(__tstate);
18122 if (PyErr_Occurred()) SWIG_fail;
18123 }
18124 {
18125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18126 }
18127 return resultobj;
18128 fail:
18129 return NULL;
18130 }
18131
18132
18133 static PyObject *_wrap_MetaFile_SetClipboard(PyObject *, PyObject *args, PyObject *kwargs) {
18134 PyObject *resultobj;
18135 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18136 int arg2 = (int) 0 ;
18137 int arg3 = (int) 0 ;
18138 bool result;
18139 PyObject * obj0 = 0 ;
18140 PyObject * obj1 = 0 ;
18141 PyObject * obj2 = 0 ;
18142 char *kwnames[] = {
18143 (char *) "self",(char *) "width",(char *) "height", NULL
18144 };
18145
18146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MetaFile_SetClipboard",kwnames,&obj0,&obj1,&obj2)) goto fail;
18147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18148 if (SWIG_arg_fail(1)) SWIG_fail;
18149 if (obj1) {
18150 {
18151 arg2 = (int)(SWIG_As_int(obj1));
18152 if (SWIG_arg_fail(2)) SWIG_fail;
18153 }
18154 }
18155 if (obj2) {
18156 {
18157 arg3 = (int)(SWIG_As_int(obj2));
18158 if (SWIG_arg_fail(3)) SWIG_fail;
18159 }
18160 }
18161 {
18162 PyThreadState* __tstate = wxPyBeginAllowThreads();
18163 result = (bool)(arg1)->SetClipboard(arg2,arg3);
18164
18165 wxPyEndAllowThreads(__tstate);
18166 if (PyErr_Occurred()) SWIG_fail;
18167 }
18168 {
18169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18170 }
18171 return resultobj;
18172 fail:
18173 return NULL;
18174 }
18175
18176
18177 static PyObject *_wrap_MetaFile_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18178 PyObject *resultobj;
18179 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18180 wxSize result;
18181 PyObject * obj0 = 0 ;
18182 char *kwnames[] = {
18183 (char *) "self", NULL
18184 };
18185
18186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetSize",kwnames,&obj0)) goto fail;
18187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18188 if (SWIG_arg_fail(1)) SWIG_fail;
18189 {
18190 PyThreadState* __tstate = wxPyBeginAllowThreads();
18191 result = (arg1)->GetSize();
18192
18193 wxPyEndAllowThreads(__tstate);
18194 if (PyErr_Occurred()) SWIG_fail;
18195 }
18196 {
18197 wxSize * resultptr;
18198 resultptr = new wxSize((wxSize &)(result));
18199 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18200 }
18201 return resultobj;
18202 fail:
18203 return NULL;
18204 }
18205
18206
18207 static PyObject *_wrap_MetaFile_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
18208 PyObject *resultobj;
18209 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18210 int result;
18211 PyObject * obj0 = 0 ;
18212 char *kwnames[] = {
18213 (char *) "self", NULL
18214 };
18215
18216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetWidth",kwnames,&obj0)) goto fail;
18217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18218 if (SWIG_arg_fail(1)) SWIG_fail;
18219 {
18220 PyThreadState* __tstate = wxPyBeginAllowThreads();
18221 result = (int)(arg1)->GetWidth();
18222
18223 wxPyEndAllowThreads(__tstate);
18224 if (PyErr_Occurred()) SWIG_fail;
18225 }
18226 {
18227 resultobj = SWIG_From_int((int)(result));
18228 }
18229 return resultobj;
18230 fail:
18231 return NULL;
18232 }
18233
18234
18235 static PyObject *_wrap_MetaFile_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
18236 PyObject *resultobj;
18237 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18238 int result;
18239 PyObject * obj0 = 0 ;
18240 char *kwnames[] = {
18241 (char *) "self", NULL
18242 };
18243
18244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetHeight",kwnames,&obj0)) goto fail;
18245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18246 if (SWIG_arg_fail(1)) SWIG_fail;
18247 {
18248 PyThreadState* __tstate = wxPyBeginAllowThreads();
18249 result = (int)(arg1)->GetHeight();
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 * MetaFile_swigregister(PyObject *, PyObject *args) {
18264 PyObject *obj;
18265 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18266 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
18267 Py_INCREF(obj);
18268 return Py_BuildValue((char *)"");
18269 }
18270 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
18271 PyObject *resultobj;
18272 wxString const &arg1_defvalue = wxPyEmptyString ;
18273 wxString *arg1 = (wxString *) &arg1_defvalue ;
18274 int arg2 = (int) 0 ;
18275 int arg3 = (int) 0 ;
18276 wxString const &arg4_defvalue = wxPyEmptyString ;
18277 wxString *arg4 = (wxString *) &arg4_defvalue ;
18278 wxMetaFileDC *result;
18279 bool temp1 = false ;
18280 bool temp4 = false ;
18281 PyObject * obj0 = 0 ;
18282 PyObject * obj1 = 0 ;
18283 PyObject * obj2 = 0 ;
18284 PyObject * obj3 = 0 ;
18285 char *kwnames[] = {
18286 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
18287 };
18288
18289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18290 if (obj0) {
18291 {
18292 arg1 = wxString_in_helper(obj0);
18293 if (arg1 == NULL) SWIG_fail;
18294 temp1 = true;
18295 }
18296 }
18297 if (obj1) {
18298 {
18299 arg2 = (int)(SWIG_As_int(obj1));
18300 if (SWIG_arg_fail(2)) SWIG_fail;
18301 }
18302 }
18303 if (obj2) {
18304 {
18305 arg3 = (int)(SWIG_As_int(obj2));
18306 if (SWIG_arg_fail(3)) SWIG_fail;
18307 }
18308 }
18309 if (obj3) {
18310 {
18311 arg4 = wxString_in_helper(obj3);
18312 if (arg4 == NULL) SWIG_fail;
18313 temp4 = true;
18314 }
18315 }
18316 {
18317 if (!wxPyCheckForApp()) SWIG_fail;
18318 PyThreadState* __tstate = wxPyBeginAllowThreads();
18319 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
18320
18321 wxPyEndAllowThreads(__tstate);
18322 if (PyErr_Occurred()) SWIG_fail;
18323 }
18324 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
18325 {
18326 if (temp1)
18327 delete arg1;
18328 }
18329 {
18330 if (temp4)
18331 delete arg4;
18332 }
18333 return resultobj;
18334 fail:
18335 {
18336 if (temp1)
18337 delete arg1;
18338 }
18339 {
18340 if (temp4)
18341 delete arg4;
18342 }
18343 return NULL;
18344 }
18345
18346
18347 static PyObject *_wrap_MetaFileDC_Close(PyObject *, PyObject *args, PyObject *kwargs) {
18348 PyObject *resultobj;
18349 wxMetaFileDC *arg1 = (wxMetaFileDC *) 0 ;
18350 wxMetaFile *result;
18351 PyObject * obj0 = 0 ;
18352 char *kwnames[] = {
18353 (char *) "self", NULL
18354 };
18355
18356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFileDC_Close",kwnames,&obj0)) goto fail;
18357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFileDC, SWIG_POINTER_EXCEPTION | 0);
18358 if (SWIG_arg_fail(1)) SWIG_fail;
18359 {
18360 PyThreadState* __tstate = wxPyBeginAllowThreads();
18361 result = (wxMetaFile *)(arg1)->Close();
18362
18363 wxPyEndAllowThreads(__tstate);
18364 if (PyErr_Occurred()) SWIG_fail;
18365 }
18366 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 0);
18367 return resultobj;
18368 fail:
18369 return NULL;
18370 }
18371
18372
18373 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
18374 PyObject *obj;
18375 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18376 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
18377 Py_INCREF(obj);
18378 return Py_BuildValue((char *)"");
18379 }
18380 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
18381 PyObject *resultobj;
18382 wxPrintData *arg1 = 0 ;
18383 wxPrinterDC *result;
18384 PyObject * obj0 = 0 ;
18385 char *kwnames[] = {
18386 (char *) "printData", NULL
18387 };
18388
18389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
18390 {
18391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18392 if (SWIG_arg_fail(1)) SWIG_fail;
18393 if (arg1 == NULL) {
18394 SWIG_null_ref("wxPrintData");
18395 }
18396 if (SWIG_arg_fail(1)) SWIG_fail;
18397 }
18398 {
18399 if (!wxPyCheckForApp()) SWIG_fail;
18400 PyThreadState* __tstate = wxPyBeginAllowThreads();
18401 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
18402
18403 wxPyEndAllowThreads(__tstate);
18404 if (PyErr_Occurred()) SWIG_fail;
18405 }
18406 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
18407 return resultobj;
18408 fail:
18409 return NULL;
18410 }
18411
18412
18413 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
18414 PyObject *obj;
18415 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18416 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
18417 Py_INCREF(obj);
18418 return Py_BuildValue((char *)"");
18419 }
18420 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18421 PyObject *resultobj;
18422 int arg1 ;
18423 int arg2 ;
18424 int arg3 = (int) true ;
18425 int arg4 = (int) 1 ;
18426 wxImageList *result;
18427 PyObject * obj0 = 0 ;
18428 PyObject * obj1 = 0 ;
18429 PyObject * obj2 = 0 ;
18430 PyObject * obj3 = 0 ;
18431 char *kwnames[] = {
18432 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
18433 };
18434
18435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18436 {
18437 arg1 = (int)(SWIG_As_int(obj0));
18438 if (SWIG_arg_fail(1)) SWIG_fail;
18439 }
18440 {
18441 arg2 = (int)(SWIG_As_int(obj1));
18442 if (SWIG_arg_fail(2)) SWIG_fail;
18443 }
18444 if (obj2) {
18445 {
18446 arg3 = (int)(SWIG_As_int(obj2));
18447 if (SWIG_arg_fail(3)) SWIG_fail;
18448 }
18449 }
18450 if (obj3) {
18451 {
18452 arg4 = (int)(SWIG_As_int(obj3));
18453 if (SWIG_arg_fail(4)) SWIG_fail;
18454 }
18455 }
18456 {
18457 if (!wxPyCheckForApp()) SWIG_fail;
18458 PyThreadState* __tstate = wxPyBeginAllowThreads();
18459 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
18460
18461 wxPyEndAllowThreads(__tstate);
18462 if (PyErr_Occurred()) SWIG_fail;
18463 }
18464 {
18465 resultobj = wxPyMake_wxObject(result, 1);
18466 }
18467 return resultobj;
18468 fail:
18469 return NULL;
18470 }
18471
18472
18473 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18474 PyObject *resultobj;
18475 wxImageList *arg1 = (wxImageList *) 0 ;
18476 PyObject * obj0 = 0 ;
18477 char *kwnames[] = {
18478 (char *) "self", NULL
18479 };
18480
18481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
18482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18483 if (SWIG_arg_fail(1)) SWIG_fail;
18484 {
18485 PyThreadState* __tstate = wxPyBeginAllowThreads();
18486 delete arg1;
18487
18488 wxPyEndAllowThreads(__tstate);
18489 if (PyErr_Occurred()) SWIG_fail;
18490 }
18491 Py_INCREF(Py_None); resultobj = Py_None;
18492 return resultobj;
18493 fail:
18494 return NULL;
18495 }
18496
18497
18498 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
18499 PyObject *resultobj;
18500 wxImageList *arg1 = (wxImageList *) 0 ;
18501 wxBitmap *arg2 = 0 ;
18502 wxBitmap const &arg3_defvalue = wxNullBitmap ;
18503 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
18504 int result;
18505 PyObject * obj0 = 0 ;
18506 PyObject * obj1 = 0 ;
18507 PyObject * obj2 = 0 ;
18508 char *kwnames[] = {
18509 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
18510 };
18511
18512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
18513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18514 if (SWIG_arg_fail(1)) SWIG_fail;
18515 {
18516 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18517 if (SWIG_arg_fail(2)) SWIG_fail;
18518 if (arg2 == NULL) {
18519 SWIG_null_ref("wxBitmap");
18520 }
18521 if (SWIG_arg_fail(2)) SWIG_fail;
18522 }
18523 if (obj2) {
18524 {
18525 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18526 if (SWIG_arg_fail(3)) SWIG_fail;
18527 if (arg3 == NULL) {
18528 SWIG_null_ref("wxBitmap");
18529 }
18530 if (SWIG_arg_fail(3)) SWIG_fail;
18531 }
18532 }
18533 {
18534 PyThreadState* __tstate = wxPyBeginAllowThreads();
18535 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
18536
18537 wxPyEndAllowThreads(__tstate);
18538 if (PyErr_Occurred()) SWIG_fail;
18539 }
18540 {
18541 resultobj = SWIG_From_int((int)(result));
18542 }
18543 return resultobj;
18544 fail:
18545 return NULL;
18546 }
18547
18548
18549 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
18550 PyObject *resultobj;
18551 wxImageList *arg1 = (wxImageList *) 0 ;
18552 wxBitmap *arg2 = 0 ;
18553 wxColour *arg3 = 0 ;
18554 int result;
18555 wxColour temp3 ;
18556 PyObject * obj0 = 0 ;
18557 PyObject * obj1 = 0 ;
18558 PyObject * obj2 = 0 ;
18559 char *kwnames[] = {
18560 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
18561 };
18562
18563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
18564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18565 if (SWIG_arg_fail(1)) SWIG_fail;
18566 {
18567 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18568 if (SWIG_arg_fail(2)) SWIG_fail;
18569 if (arg2 == NULL) {
18570 SWIG_null_ref("wxBitmap");
18571 }
18572 if (SWIG_arg_fail(2)) SWIG_fail;
18573 }
18574 {
18575 arg3 = &temp3;
18576 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
18577 }
18578 {
18579 PyThreadState* __tstate = wxPyBeginAllowThreads();
18580 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
18581
18582 wxPyEndAllowThreads(__tstate);
18583 if (PyErr_Occurred()) SWIG_fail;
18584 }
18585 {
18586 resultobj = SWIG_From_int((int)(result));
18587 }
18588 return resultobj;
18589 fail:
18590 return NULL;
18591 }
18592
18593
18594 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18595 PyObject *resultobj;
18596 wxImageList *arg1 = (wxImageList *) 0 ;
18597 wxIcon *arg2 = 0 ;
18598 int result;
18599 PyObject * obj0 = 0 ;
18600 PyObject * obj1 = 0 ;
18601 char *kwnames[] = {
18602 (char *) "self",(char *) "icon", NULL
18603 };
18604
18605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
18606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18607 if (SWIG_arg_fail(1)) SWIG_fail;
18608 {
18609 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
18610 if (SWIG_arg_fail(2)) SWIG_fail;
18611 if (arg2 == NULL) {
18612 SWIG_null_ref("wxIcon");
18613 }
18614 if (SWIG_arg_fail(2)) SWIG_fail;
18615 }
18616 {
18617 PyThreadState* __tstate = wxPyBeginAllowThreads();
18618 result = (int)(arg1)->Add((wxIcon const &)*arg2);
18619
18620 wxPyEndAllowThreads(__tstate);
18621 if (PyErr_Occurred()) SWIG_fail;
18622 }
18623 {
18624 resultobj = SWIG_From_int((int)(result));
18625 }
18626 return resultobj;
18627 fail:
18628 return NULL;
18629 }
18630
18631
18632 static PyObject *_wrap_ImageList_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
18633 PyObject *resultobj;
18634 wxImageList *arg1 = (wxImageList *) 0 ;
18635 int arg2 ;
18636 SwigValueWrapper<wxBitmap > result;
18637 PyObject * obj0 = 0 ;
18638 PyObject * obj1 = 0 ;
18639 char *kwnames[] = {
18640 (char *) "self",(char *) "index", NULL
18641 };
18642
18643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) goto fail;
18644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18645 if (SWIG_arg_fail(1)) SWIG_fail;
18646 {
18647 arg2 = (int)(SWIG_As_int(obj1));
18648 if (SWIG_arg_fail(2)) SWIG_fail;
18649 }
18650 {
18651 PyThreadState* __tstate = wxPyBeginAllowThreads();
18652 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
18653
18654 wxPyEndAllowThreads(__tstate);
18655 if (PyErr_Occurred()) SWIG_fail;
18656 }
18657 {
18658 wxBitmap * resultptr;
18659 resultptr = new wxBitmap((wxBitmap &)(result));
18660 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
18661 }
18662 return resultobj;
18663 fail:
18664 return NULL;
18665 }
18666
18667
18668 static PyObject *_wrap_ImageList_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18669 PyObject *resultobj;
18670 wxImageList *arg1 = (wxImageList *) 0 ;
18671 int arg2 ;
18672 wxIcon result;
18673 PyObject * obj0 = 0 ;
18674 PyObject * obj1 = 0 ;
18675 char *kwnames[] = {
18676 (char *) "self",(char *) "index", NULL
18677 };
18678
18679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) goto fail;
18680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18681 if (SWIG_arg_fail(1)) SWIG_fail;
18682 {
18683 arg2 = (int)(SWIG_As_int(obj1));
18684 if (SWIG_arg_fail(2)) SWIG_fail;
18685 }
18686 {
18687 PyThreadState* __tstate = wxPyBeginAllowThreads();
18688 result = ((wxImageList const *)arg1)->GetIcon(arg2);
18689
18690 wxPyEndAllowThreads(__tstate);
18691 if (PyErr_Occurred()) SWIG_fail;
18692 }
18693 {
18694 wxIcon * resultptr;
18695 resultptr = new wxIcon((wxIcon &)(result));
18696 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
18697 }
18698 return resultobj;
18699 fail:
18700 return NULL;
18701 }
18702
18703
18704 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
18705 PyObject *resultobj;
18706 wxImageList *arg1 = (wxImageList *) 0 ;
18707 int arg2 ;
18708 wxBitmap *arg3 = 0 ;
18709 bool result;
18710 PyObject * obj0 = 0 ;
18711 PyObject * obj1 = 0 ;
18712 PyObject * obj2 = 0 ;
18713 char *kwnames[] = {
18714 (char *) "self",(char *) "index",(char *) "bitmap", NULL
18715 };
18716
18717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_Replace",kwnames,&obj0,&obj1,&obj2)) goto fail;
18718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18719 if (SWIG_arg_fail(1)) SWIG_fail;
18720 {
18721 arg2 = (int)(SWIG_As_int(obj1));
18722 if (SWIG_arg_fail(2)) SWIG_fail;
18723 }
18724 {
18725 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18726 if (SWIG_arg_fail(3)) SWIG_fail;
18727 if (arg3 == NULL) {
18728 SWIG_null_ref("wxBitmap");
18729 }
18730 if (SWIG_arg_fail(3)) SWIG_fail;
18731 }
18732 {
18733 PyThreadState* __tstate = wxPyBeginAllowThreads();
18734 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3);
18735
18736 wxPyEndAllowThreads(__tstate);
18737 if (PyErr_Occurred()) SWIG_fail;
18738 }
18739 {
18740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18741 }
18742 return resultobj;
18743 fail:
18744 return NULL;
18745 }
18746
18747
18748 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
18749 PyObject *resultobj;
18750 wxImageList *arg1 = (wxImageList *) 0 ;
18751 int arg2 ;
18752 wxDC *arg3 = 0 ;
18753 int arg4 ;
18754 int arg5 ;
18755 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
18756 bool arg7 = (bool) (bool)false ;
18757 bool result;
18758 PyObject * obj0 = 0 ;
18759 PyObject * obj1 = 0 ;
18760 PyObject * obj2 = 0 ;
18761 PyObject * obj3 = 0 ;
18762 PyObject * obj4 = 0 ;
18763 PyObject * obj5 = 0 ;
18764 PyObject * obj6 = 0 ;
18765 char *kwnames[] = {
18766 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
18767 };
18768
18769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
18770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18771 if (SWIG_arg_fail(1)) SWIG_fail;
18772 {
18773 arg2 = (int)(SWIG_As_int(obj1));
18774 if (SWIG_arg_fail(2)) SWIG_fail;
18775 }
18776 {
18777 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18778 if (SWIG_arg_fail(3)) SWIG_fail;
18779 if (arg3 == NULL) {
18780 SWIG_null_ref("wxDC");
18781 }
18782 if (SWIG_arg_fail(3)) SWIG_fail;
18783 }
18784 {
18785 arg4 = (int)(SWIG_As_int(obj3));
18786 if (SWIG_arg_fail(4)) SWIG_fail;
18787 }
18788 {
18789 arg5 = (int)(SWIG_As_int(obj4));
18790 if (SWIG_arg_fail(5)) SWIG_fail;
18791 }
18792 if (obj5) {
18793 {
18794 arg6 = (int)(SWIG_As_int(obj5));
18795 if (SWIG_arg_fail(6)) SWIG_fail;
18796 }
18797 }
18798 if (obj6) {
18799 {
18800 arg7 = (bool const)(SWIG_As_bool(obj6));
18801 if (SWIG_arg_fail(7)) SWIG_fail;
18802 }
18803 }
18804 {
18805 PyThreadState* __tstate = wxPyBeginAllowThreads();
18806 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
18807
18808 wxPyEndAllowThreads(__tstate);
18809 if (PyErr_Occurred()) SWIG_fail;
18810 }
18811 {
18812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18813 }
18814 return resultobj;
18815 fail:
18816 return NULL;
18817 }
18818
18819
18820 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
18821 PyObject *resultobj;
18822 wxImageList *arg1 = (wxImageList *) 0 ;
18823 int result;
18824 PyObject * obj0 = 0 ;
18825 char *kwnames[] = {
18826 (char *) "self", NULL
18827 };
18828
18829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
18830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18831 if (SWIG_arg_fail(1)) SWIG_fail;
18832 {
18833 PyThreadState* __tstate = wxPyBeginAllowThreads();
18834 result = (int)(arg1)->GetImageCount();
18835
18836 wxPyEndAllowThreads(__tstate);
18837 if (PyErr_Occurred()) SWIG_fail;
18838 }
18839 {
18840 resultobj = SWIG_From_int((int)(result));
18841 }
18842 return resultobj;
18843 fail:
18844 return NULL;
18845 }
18846
18847
18848 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
18849 PyObject *resultobj;
18850 wxImageList *arg1 = (wxImageList *) 0 ;
18851 int arg2 ;
18852 bool result;
18853 PyObject * obj0 = 0 ;
18854 PyObject * obj1 = 0 ;
18855 char *kwnames[] = {
18856 (char *) "self",(char *) "index", NULL
18857 };
18858
18859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
18860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18861 if (SWIG_arg_fail(1)) SWIG_fail;
18862 {
18863 arg2 = (int)(SWIG_As_int(obj1));
18864 if (SWIG_arg_fail(2)) SWIG_fail;
18865 }
18866 {
18867 PyThreadState* __tstate = wxPyBeginAllowThreads();
18868 result = (bool)(arg1)->Remove(arg2);
18869
18870 wxPyEndAllowThreads(__tstate);
18871 if (PyErr_Occurred()) SWIG_fail;
18872 }
18873 {
18874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18875 }
18876 return resultobj;
18877 fail:
18878 return NULL;
18879 }
18880
18881
18882 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
18883 PyObject *resultobj;
18884 wxImageList *arg1 = (wxImageList *) 0 ;
18885 bool result;
18886 PyObject * obj0 = 0 ;
18887 char *kwnames[] = {
18888 (char *) "self", NULL
18889 };
18890
18891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
18892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18893 if (SWIG_arg_fail(1)) SWIG_fail;
18894 {
18895 PyThreadState* __tstate = wxPyBeginAllowThreads();
18896 result = (bool)(arg1)->RemoveAll();
18897
18898 wxPyEndAllowThreads(__tstate);
18899 if (PyErr_Occurred()) SWIG_fail;
18900 }
18901 {
18902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18903 }
18904 return resultobj;
18905 fail:
18906 return NULL;
18907 }
18908
18909
18910 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18911 PyObject *resultobj;
18912 wxImageList *arg1 = (wxImageList *) 0 ;
18913 int arg2 ;
18914 int *arg3 = 0 ;
18915 int *arg4 = 0 ;
18916 int temp3 ;
18917 int res3 = 0 ;
18918 int temp4 ;
18919 int res4 = 0 ;
18920 PyObject * obj0 = 0 ;
18921 PyObject * obj1 = 0 ;
18922 char *kwnames[] = {
18923 (char *) "self",(char *) "index", NULL
18924 };
18925
18926 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18927 arg4 = &temp4; res4 = SWIG_NEWOBJ;
18928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
18929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18930 if (SWIG_arg_fail(1)) SWIG_fail;
18931 {
18932 arg2 = (int)(SWIG_As_int(obj1));
18933 if (SWIG_arg_fail(2)) SWIG_fail;
18934 }
18935 {
18936 PyThreadState* __tstate = wxPyBeginAllowThreads();
18937 (arg1)->GetSize(arg2,*arg3,*arg4);
18938
18939 wxPyEndAllowThreads(__tstate);
18940 if (PyErr_Occurred()) SWIG_fail;
18941 }
18942 Py_INCREF(Py_None); resultobj = Py_None;
18943 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18944 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18945 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
18946 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
18947 return resultobj;
18948 fail:
18949 return NULL;
18950 }
18951
18952
18953 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
18954 PyObject *obj;
18955 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18956 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
18957 Py_INCREF(obj);
18958 return Py_BuildValue((char *)"");
18959 }
18960 static int _wrap_NORMAL_FONT_set(PyObject *) {
18961 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
18962 return 1;
18963 }
18964
18965
18966 static PyObject *_wrap_NORMAL_FONT_get(void) {
18967 PyObject *pyobj;
18968
18969 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
18970 return pyobj;
18971 }
18972
18973
18974 static int _wrap_SMALL_FONT_set(PyObject *) {
18975 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
18976 return 1;
18977 }
18978
18979
18980 static PyObject *_wrap_SMALL_FONT_get(void) {
18981 PyObject *pyobj;
18982
18983 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
18984 return pyobj;
18985 }
18986
18987
18988 static int _wrap_ITALIC_FONT_set(PyObject *) {
18989 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
18990 return 1;
18991 }
18992
18993
18994 static PyObject *_wrap_ITALIC_FONT_get(void) {
18995 PyObject *pyobj;
18996
18997 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
18998 return pyobj;
18999 }
19000
19001
19002 static int _wrap_SWISS_FONT_set(PyObject *) {
19003 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
19004 return 1;
19005 }
19006
19007
19008 static PyObject *_wrap_SWISS_FONT_get(void) {
19009 PyObject *pyobj;
19010
19011 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
19012 return pyobj;
19013 }
19014
19015
19016 static int _wrap_RED_PEN_set(PyObject *) {
19017 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
19018 return 1;
19019 }
19020
19021
19022 static PyObject *_wrap_RED_PEN_get(void) {
19023 PyObject *pyobj;
19024
19025 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
19026 return pyobj;
19027 }
19028
19029
19030 static int _wrap_CYAN_PEN_set(PyObject *) {
19031 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
19032 return 1;
19033 }
19034
19035
19036 static PyObject *_wrap_CYAN_PEN_get(void) {
19037 PyObject *pyobj;
19038
19039 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
19040 return pyobj;
19041 }
19042
19043
19044 static int _wrap_GREEN_PEN_set(PyObject *) {
19045 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
19046 return 1;
19047 }
19048
19049
19050 static PyObject *_wrap_GREEN_PEN_get(void) {
19051 PyObject *pyobj;
19052
19053 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
19054 return pyobj;
19055 }
19056
19057
19058 static int _wrap_BLACK_PEN_set(PyObject *) {
19059 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
19060 return 1;
19061 }
19062
19063
19064 static PyObject *_wrap_BLACK_PEN_get(void) {
19065 PyObject *pyobj;
19066
19067 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
19068 return pyobj;
19069 }
19070
19071
19072 static int _wrap_WHITE_PEN_set(PyObject *) {
19073 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
19074 return 1;
19075 }
19076
19077
19078 static PyObject *_wrap_WHITE_PEN_get(void) {
19079 PyObject *pyobj;
19080
19081 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
19082 return pyobj;
19083 }
19084
19085
19086 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
19087 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
19088 return 1;
19089 }
19090
19091
19092 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
19093 PyObject *pyobj;
19094
19095 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
19096 return pyobj;
19097 }
19098
19099
19100 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
19101 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
19102 return 1;
19103 }
19104
19105
19106 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
19107 PyObject *pyobj;
19108
19109 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
19110 return pyobj;
19111 }
19112
19113
19114 static int _wrap_GREY_PEN_set(PyObject *) {
19115 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
19116 return 1;
19117 }
19118
19119
19120 static PyObject *_wrap_GREY_PEN_get(void) {
19121 PyObject *pyobj;
19122
19123 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
19124 return pyobj;
19125 }
19126
19127
19128 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
19129 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
19130 return 1;
19131 }
19132
19133
19134 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
19135 PyObject *pyobj;
19136
19137 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19138 return pyobj;
19139 }
19140
19141
19142 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
19143 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
19144 return 1;
19145 }
19146
19147
19148 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
19149 PyObject *pyobj;
19150
19151 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19152 return pyobj;
19153 }
19154
19155
19156 static int _wrap_BLUE_BRUSH_set(PyObject *) {
19157 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
19158 return 1;
19159 }
19160
19161
19162 static PyObject *_wrap_BLUE_BRUSH_get(void) {
19163 PyObject *pyobj;
19164
19165 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19166 return pyobj;
19167 }
19168
19169
19170 static int _wrap_GREEN_BRUSH_set(PyObject *) {
19171 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
19172 return 1;
19173 }
19174
19175
19176 static PyObject *_wrap_GREEN_BRUSH_get(void) {
19177 PyObject *pyobj;
19178
19179 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19180 return pyobj;
19181 }
19182
19183
19184 static int _wrap_WHITE_BRUSH_set(PyObject *) {
19185 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
19186 return 1;
19187 }
19188
19189
19190 static PyObject *_wrap_WHITE_BRUSH_get(void) {
19191 PyObject *pyobj;
19192
19193 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19194 return pyobj;
19195 }
19196
19197
19198 static int _wrap_BLACK_BRUSH_set(PyObject *) {
19199 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
19200 return 1;
19201 }
19202
19203
19204 static PyObject *_wrap_BLACK_BRUSH_get(void) {
19205 PyObject *pyobj;
19206
19207 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
19208 return pyobj;
19209 }
19210
19211
19212 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
19213 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
19214 return 1;
19215 }
19216
19217
19218 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
19219 PyObject *pyobj;
19220
19221 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
19222 return pyobj;
19223 }
19224
19225
19226 static int _wrap_CYAN_BRUSH_set(PyObject *) {
19227 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
19228 return 1;
19229 }
19230
19231
19232 static PyObject *_wrap_CYAN_BRUSH_get(void) {
19233 PyObject *pyobj;
19234
19235 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19236 return pyobj;
19237 }
19238
19239
19240 static int _wrap_RED_BRUSH_set(PyObject *) {
19241 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
19242 return 1;
19243 }
19244
19245
19246 static PyObject *_wrap_RED_BRUSH_get(void) {
19247 PyObject *pyobj;
19248
19249 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
19250 return pyobj;
19251 }
19252
19253
19254 static int _wrap_GREY_BRUSH_set(PyObject *) {
19255 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
19256 return 1;
19257 }
19258
19259
19260 static PyObject *_wrap_GREY_BRUSH_get(void) {
19261 PyObject *pyobj;
19262
19263 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19264 return pyobj;
19265 }
19266
19267
19268 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
19269 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
19270 return 1;
19271 }
19272
19273
19274 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
19275 PyObject *pyobj;
19276
19277 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19278 return pyobj;
19279 }
19280
19281
19282 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
19283 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
19284 return 1;
19285 }
19286
19287
19288 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
19289 PyObject *pyobj;
19290
19291 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19292 return pyobj;
19293 }
19294
19295
19296 static int _wrap_BLACK_set(PyObject *) {
19297 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
19298 return 1;
19299 }
19300
19301
19302 static PyObject *_wrap_BLACK_get(void) {
19303 PyObject *pyobj;
19304
19305 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
19306 return pyobj;
19307 }
19308
19309
19310 static int _wrap_WHITE_set(PyObject *) {
19311 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
19312 return 1;
19313 }
19314
19315
19316 static PyObject *_wrap_WHITE_get(void) {
19317 PyObject *pyobj;
19318
19319 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
19320 return pyobj;
19321 }
19322
19323
19324 static int _wrap_RED_set(PyObject *) {
19325 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
19326 return 1;
19327 }
19328
19329
19330 static PyObject *_wrap_RED_get(void) {
19331 PyObject *pyobj;
19332
19333 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
19334 return pyobj;
19335 }
19336
19337
19338 static int _wrap_BLUE_set(PyObject *) {
19339 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
19340 return 1;
19341 }
19342
19343
19344 static PyObject *_wrap_BLUE_get(void) {
19345 PyObject *pyobj;
19346
19347 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
19348 return pyobj;
19349 }
19350
19351
19352 static int _wrap_GREEN_set(PyObject *) {
19353 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
19354 return 1;
19355 }
19356
19357
19358 static PyObject *_wrap_GREEN_get(void) {
19359 PyObject *pyobj;
19360
19361 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
19362 return pyobj;
19363 }
19364
19365
19366 static int _wrap_CYAN_set(PyObject *) {
19367 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
19368 return 1;
19369 }
19370
19371
19372 static PyObject *_wrap_CYAN_get(void) {
19373 PyObject *pyobj;
19374
19375 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
19376 return pyobj;
19377 }
19378
19379
19380 static int _wrap_LIGHT_GREY_set(PyObject *) {
19381 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
19382 return 1;
19383 }
19384
19385
19386 static PyObject *_wrap_LIGHT_GREY_get(void) {
19387 PyObject *pyobj;
19388
19389 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
19390 return pyobj;
19391 }
19392
19393
19394 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
19395 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
19396 return 1;
19397 }
19398
19399
19400 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
19401 PyObject *pyobj;
19402
19403 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
19404 return pyobj;
19405 }
19406
19407
19408 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
19409 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
19410 return 1;
19411 }
19412
19413
19414 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
19415 PyObject *pyobj;
19416
19417 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19418 return pyobj;
19419 }
19420
19421
19422 static int _wrap_CROSS_CURSOR_set(PyObject *) {
19423 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
19424 return 1;
19425 }
19426
19427
19428 static PyObject *_wrap_CROSS_CURSOR_get(void) {
19429 PyObject *pyobj;
19430
19431 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19432 return pyobj;
19433 }
19434
19435
19436 static int _wrap_NullBitmap_set(PyObject *) {
19437 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
19438 return 1;
19439 }
19440
19441
19442 static PyObject *_wrap_NullBitmap_get(void) {
19443 PyObject *pyobj;
19444
19445 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
19446 return pyobj;
19447 }
19448
19449
19450 static int _wrap_NullIcon_set(PyObject *) {
19451 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
19452 return 1;
19453 }
19454
19455
19456 static PyObject *_wrap_NullIcon_get(void) {
19457 PyObject *pyobj;
19458
19459 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
19460 return pyobj;
19461 }
19462
19463
19464 static int _wrap_NullCursor_set(PyObject *) {
19465 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
19466 return 1;
19467 }
19468
19469
19470 static PyObject *_wrap_NullCursor_get(void) {
19471 PyObject *pyobj;
19472
19473 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
19474 return pyobj;
19475 }
19476
19477
19478 static int _wrap_NullPen_set(PyObject *) {
19479 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
19480 return 1;
19481 }
19482
19483
19484 static PyObject *_wrap_NullPen_get(void) {
19485 PyObject *pyobj;
19486
19487 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
19488 return pyobj;
19489 }
19490
19491
19492 static int _wrap_NullBrush_set(PyObject *) {
19493 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
19494 return 1;
19495 }
19496
19497
19498 static PyObject *_wrap_NullBrush_get(void) {
19499 PyObject *pyobj;
19500
19501 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
19502 return pyobj;
19503 }
19504
19505
19506 static int _wrap_NullPalette_set(PyObject *) {
19507 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
19508 return 1;
19509 }
19510
19511
19512 static PyObject *_wrap_NullPalette_get(void) {
19513 PyObject *pyobj;
19514
19515 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
19516 return pyobj;
19517 }
19518
19519
19520 static int _wrap_NullFont_set(PyObject *) {
19521 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
19522 return 1;
19523 }
19524
19525
19526 static PyObject *_wrap_NullFont_get(void) {
19527 PyObject *pyobj;
19528
19529 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
19530 return pyobj;
19531 }
19532
19533
19534 static int _wrap_NullColour_set(PyObject *) {
19535 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
19536 return 1;
19537 }
19538
19539
19540 static PyObject *_wrap_NullColour_get(void) {
19541 PyObject *pyobj;
19542
19543 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
19544 return pyobj;
19545 }
19546
19547
19548 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
19549 PyObject *resultobj;
19550 wxPenList *arg1 = (wxPenList *) 0 ;
19551 wxPen *arg2 = (wxPen *) 0 ;
19552 PyObject * obj0 = 0 ;
19553 PyObject * obj1 = 0 ;
19554 char *kwnames[] = {
19555 (char *) "self",(char *) "pen", NULL
19556 };
19557
19558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
19559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19560 if (SWIG_arg_fail(1)) SWIG_fail;
19561 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19562 if (SWIG_arg_fail(2)) SWIG_fail;
19563 {
19564 PyThreadState* __tstate = wxPyBeginAllowThreads();
19565 (arg1)->AddPen(arg2);
19566
19567 wxPyEndAllowThreads(__tstate);
19568 if (PyErr_Occurred()) SWIG_fail;
19569 }
19570 Py_INCREF(Py_None); resultobj = Py_None;
19571 return resultobj;
19572 fail:
19573 return NULL;
19574 }
19575
19576
19577 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
19578 PyObject *resultobj;
19579 wxPenList *arg1 = (wxPenList *) 0 ;
19580 wxColour *arg2 = 0 ;
19581 int arg3 ;
19582 int arg4 ;
19583 wxPen *result;
19584 wxColour temp2 ;
19585 PyObject * obj0 = 0 ;
19586 PyObject * obj1 = 0 ;
19587 PyObject * obj2 = 0 ;
19588 PyObject * obj3 = 0 ;
19589 char *kwnames[] = {
19590 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
19591 };
19592
19593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19595 if (SWIG_arg_fail(1)) SWIG_fail;
19596 {
19597 arg2 = &temp2;
19598 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19599 }
19600 {
19601 arg3 = (int)(SWIG_As_int(obj2));
19602 if (SWIG_arg_fail(3)) SWIG_fail;
19603 }
19604 {
19605 arg4 = (int)(SWIG_As_int(obj3));
19606 if (SWIG_arg_fail(4)) SWIG_fail;
19607 }
19608 {
19609 PyThreadState* __tstate = wxPyBeginAllowThreads();
19610 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
19611
19612 wxPyEndAllowThreads(__tstate);
19613 if (PyErr_Occurred()) SWIG_fail;
19614 }
19615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
19616 return resultobj;
19617 fail:
19618 return NULL;
19619 }
19620
19621
19622 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
19623 PyObject *resultobj;
19624 wxPenList *arg1 = (wxPenList *) 0 ;
19625 wxPen *arg2 = (wxPen *) 0 ;
19626 PyObject * obj0 = 0 ;
19627 PyObject * obj1 = 0 ;
19628 char *kwnames[] = {
19629 (char *) "self",(char *) "pen", NULL
19630 };
19631
19632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
19633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19634 if (SWIG_arg_fail(1)) SWIG_fail;
19635 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19636 if (SWIG_arg_fail(2)) SWIG_fail;
19637 {
19638 PyThreadState* __tstate = wxPyBeginAllowThreads();
19639 (arg1)->RemovePen(arg2);
19640
19641 wxPyEndAllowThreads(__tstate);
19642 if (PyErr_Occurred()) SWIG_fail;
19643 }
19644 Py_INCREF(Py_None); resultobj = Py_None;
19645 return resultobj;
19646 fail:
19647 return NULL;
19648 }
19649
19650
19651 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19652 PyObject *resultobj;
19653 wxPenList *arg1 = (wxPenList *) 0 ;
19654 int result;
19655 PyObject * obj0 = 0 ;
19656 char *kwnames[] = {
19657 (char *) "self", NULL
19658 };
19659
19660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
19661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19662 if (SWIG_arg_fail(1)) SWIG_fail;
19663 {
19664 PyThreadState* __tstate = wxPyBeginAllowThreads();
19665 result = (int)(arg1)->GetCount();
19666
19667 wxPyEndAllowThreads(__tstate);
19668 if (PyErr_Occurred()) SWIG_fail;
19669 }
19670 {
19671 resultobj = SWIG_From_int((int)(result));
19672 }
19673 return resultobj;
19674 fail:
19675 return NULL;
19676 }
19677
19678
19679 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
19680 PyObject *obj;
19681 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19682 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
19683 Py_INCREF(obj);
19684 return Py_BuildValue((char *)"");
19685 }
19686 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19687 PyObject *resultobj;
19688 wxBrushList *arg1 = (wxBrushList *) 0 ;
19689 wxBrush *arg2 = (wxBrush *) 0 ;
19690 PyObject * obj0 = 0 ;
19691 PyObject * obj1 = 0 ;
19692 char *kwnames[] = {
19693 (char *) "self",(char *) "brush", NULL
19694 };
19695
19696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
19697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19698 if (SWIG_arg_fail(1)) SWIG_fail;
19699 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19700 if (SWIG_arg_fail(2)) SWIG_fail;
19701 {
19702 PyThreadState* __tstate = wxPyBeginAllowThreads();
19703 (arg1)->AddBrush(arg2);
19704
19705 wxPyEndAllowThreads(__tstate);
19706 if (PyErr_Occurred()) SWIG_fail;
19707 }
19708 Py_INCREF(Py_None); resultobj = Py_None;
19709 return resultobj;
19710 fail:
19711 return NULL;
19712 }
19713
19714
19715 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19716 PyObject *resultobj;
19717 wxBrushList *arg1 = (wxBrushList *) 0 ;
19718 wxColour *arg2 = 0 ;
19719 int arg3 = (int) wxSOLID ;
19720 wxBrush *result;
19721 wxColour temp2 ;
19722 PyObject * obj0 = 0 ;
19723 PyObject * obj1 = 0 ;
19724 PyObject * obj2 = 0 ;
19725 char *kwnames[] = {
19726 (char *) "self",(char *) "colour",(char *) "style", NULL
19727 };
19728
19729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
19730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19731 if (SWIG_arg_fail(1)) SWIG_fail;
19732 {
19733 arg2 = &temp2;
19734 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19735 }
19736 if (obj2) {
19737 {
19738 arg3 = (int)(SWIG_As_int(obj2));
19739 if (SWIG_arg_fail(3)) SWIG_fail;
19740 }
19741 }
19742 {
19743 PyThreadState* __tstate = wxPyBeginAllowThreads();
19744 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
19745
19746 wxPyEndAllowThreads(__tstate);
19747 if (PyErr_Occurred()) SWIG_fail;
19748 }
19749 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
19750 return resultobj;
19751 fail:
19752 return NULL;
19753 }
19754
19755
19756 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19757 PyObject *resultobj;
19758 wxBrushList *arg1 = (wxBrushList *) 0 ;
19759 wxBrush *arg2 = (wxBrush *) 0 ;
19760 PyObject * obj0 = 0 ;
19761 PyObject * obj1 = 0 ;
19762 char *kwnames[] = {
19763 (char *) "self",(char *) "brush", NULL
19764 };
19765
19766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
19767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19768 if (SWIG_arg_fail(1)) SWIG_fail;
19769 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19770 if (SWIG_arg_fail(2)) SWIG_fail;
19771 {
19772 PyThreadState* __tstate = wxPyBeginAllowThreads();
19773 (arg1)->RemoveBrush(arg2);
19774
19775 wxPyEndAllowThreads(__tstate);
19776 if (PyErr_Occurred()) SWIG_fail;
19777 }
19778 Py_INCREF(Py_None); resultobj = Py_None;
19779 return resultobj;
19780 fail:
19781 return NULL;
19782 }
19783
19784
19785 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19786 PyObject *resultobj;
19787 wxBrushList *arg1 = (wxBrushList *) 0 ;
19788 int result;
19789 PyObject * obj0 = 0 ;
19790 char *kwnames[] = {
19791 (char *) "self", NULL
19792 };
19793
19794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
19795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19796 if (SWIG_arg_fail(1)) SWIG_fail;
19797 {
19798 PyThreadState* __tstate = wxPyBeginAllowThreads();
19799 result = (int)(arg1)->GetCount();
19800
19801 wxPyEndAllowThreads(__tstate);
19802 if (PyErr_Occurred()) SWIG_fail;
19803 }
19804 {
19805 resultobj = SWIG_From_int((int)(result));
19806 }
19807 return resultobj;
19808 fail:
19809 return NULL;
19810 }
19811
19812
19813 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
19814 PyObject *obj;
19815 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19816 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
19817 Py_INCREF(obj);
19818 return Py_BuildValue((char *)"");
19819 }
19820 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19821 PyObject *resultobj;
19822 wxColourDatabase *result;
19823 char *kwnames[] = {
19824 NULL
19825 };
19826
19827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
19828 {
19829 if (!wxPyCheckForApp()) SWIG_fail;
19830 PyThreadState* __tstate = wxPyBeginAllowThreads();
19831 result = (wxColourDatabase *)new wxColourDatabase();
19832
19833 wxPyEndAllowThreads(__tstate);
19834 if (PyErr_Occurred()) SWIG_fail;
19835 }
19836 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
19837 return resultobj;
19838 fail:
19839 return NULL;
19840 }
19841
19842
19843 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19844 PyObject *resultobj;
19845 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19846 PyObject * obj0 = 0 ;
19847 char *kwnames[] = {
19848 (char *) "self", NULL
19849 };
19850
19851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
19852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19853 if (SWIG_arg_fail(1)) SWIG_fail;
19854 {
19855 PyThreadState* __tstate = wxPyBeginAllowThreads();
19856 delete arg1;
19857
19858 wxPyEndAllowThreads(__tstate);
19859 if (PyErr_Occurred()) SWIG_fail;
19860 }
19861 Py_INCREF(Py_None); resultobj = Py_None;
19862 return resultobj;
19863 fail:
19864 return NULL;
19865 }
19866
19867
19868 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
19869 PyObject *resultobj;
19870 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19871 wxString *arg2 = 0 ;
19872 wxColour result;
19873 bool temp2 = false ;
19874 PyObject * obj0 = 0 ;
19875 PyObject * obj1 = 0 ;
19876 char *kwnames[] = {
19877 (char *) "self",(char *) "name", NULL
19878 };
19879
19880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
19881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19882 if (SWIG_arg_fail(1)) SWIG_fail;
19883 {
19884 arg2 = wxString_in_helper(obj1);
19885 if (arg2 == NULL) SWIG_fail;
19886 temp2 = true;
19887 }
19888 {
19889 PyThreadState* __tstate = wxPyBeginAllowThreads();
19890 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
19891
19892 wxPyEndAllowThreads(__tstate);
19893 if (PyErr_Occurred()) SWIG_fail;
19894 }
19895 {
19896 wxColour * resultptr;
19897 resultptr = new wxColour((wxColour &)(result));
19898 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19899 }
19900 {
19901 if (temp2)
19902 delete arg2;
19903 }
19904 return resultobj;
19905 fail:
19906 {
19907 if (temp2)
19908 delete arg2;
19909 }
19910 return NULL;
19911 }
19912
19913
19914 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
19915 PyObject *resultobj;
19916 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19917 wxColour *arg2 = 0 ;
19918 wxString result;
19919 wxColour temp2 ;
19920 PyObject * obj0 = 0 ;
19921 PyObject * obj1 = 0 ;
19922 char *kwnames[] = {
19923 (char *) "self",(char *) "colour", NULL
19924 };
19925
19926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
19927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19928 if (SWIG_arg_fail(1)) SWIG_fail;
19929 {
19930 arg2 = &temp2;
19931 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19932 }
19933 {
19934 PyThreadState* __tstate = wxPyBeginAllowThreads();
19935 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
19936
19937 wxPyEndAllowThreads(__tstate);
19938 if (PyErr_Occurred()) SWIG_fail;
19939 }
19940 {
19941 #if wxUSE_UNICODE
19942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19943 #else
19944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19945 #endif
19946 }
19947 return resultobj;
19948 fail:
19949 return NULL;
19950 }
19951
19952
19953 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
19954 PyObject *resultobj;
19955 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19956 wxString *arg2 = 0 ;
19957 wxColour *arg3 = 0 ;
19958 bool temp2 = false ;
19959 wxColour temp3 ;
19960 PyObject * obj0 = 0 ;
19961 PyObject * obj1 = 0 ;
19962 PyObject * obj2 = 0 ;
19963 char *kwnames[] = {
19964 (char *) "self",(char *) "name",(char *) "colour", NULL
19965 };
19966
19967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
19968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19969 if (SWIG_arg_fail(1)) SWIG_fail;
19970 {
19971 arg2 = wxString_in_helper(obj1);
19972 if (arg2 == NULL) SWIG_fail;
19973 temp2 = true;
19974 }
19975 {
19976 arg3 = &temp3;
19977 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19978 }
19979 {
19980 PyThreadState* __tstate = wxPyBeginAllowThreads();
19981 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
19982
19983 wxPyEndAllowThreads(__tstate);
19984 if (PyErr_Occurred()) SWIG_fail;
19985 }
19986 Py_INCREF(Py_None); resultobj = Py_None;
19987 {
19988 if (temp2)
19989 delete arg2;
19990 }
19991 return resultobj;
19992 fail:
19993 {
19994 if (temp2)
19995 delete arg2;
19996 }
19997 return NULL;
19998 }
19999
20000
20001 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
20002 PyObject *resultobj;
20003 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20004 wxString *arg2 = 0 ;
20005 int arg3 ;
20006 int arg4 ;
20007 int arg5 ;
20008 bool temp2 = false ;
20009 PyObject * obj0 = 0 ;
20010 PyObject * obj1 = 0 ;
20011 PyObject * obj2 = 0 ;
20012 PyObject * obj3 = 0 ;
20013 PyObject * obj4 = 0 ;
20014 char *kwnames[] = {
20015 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
20016 };
20017
20018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20020 if (SWIG_arg_fail(1)) SWIG_fail;
20021 {
20022 arg2 = wxString_in_helper(obj1);
20023 if (arg2 == NULL) SWIG_fail;
20024 temp2 = true;
20025 }
20026 {
20027 arg3 = (int)(SWIG_As_int(obj2));
20028 if (SWIG_arg_fail(3)) SWIG_fail;
20029 }
20030 {
20031 arg4 = (int)(SWIG_As_int(obj3));
20032 if (SWIG_arg_fail(4)) SWIG_fail;
20033 }
20034 {
20035 arg5 = (int)(SWIG_As_int(obj4));
20036 if (SWIG_arg_fail(5)) SWIG_fail;
20037 }
20038 {
20039 PyThreadState* __tstate = wxPyBeginAllowThreads();
20040 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
20041
20042 wxPyEndAllowThreads(__tstate);
20043 if (PyErr_Occurred()) SWIG_fail;
20044 }
20045 Py_INCREF(Py_None); resultobj = Py_None;
20046 {
20047 if (temp2)
20048 delete arg2;
20049 }
20050 return resultobj;
20051 fail:
20052 {
20053 if (temp2)
20054 delete arg2;
20055 }
20056 return NULL;
20057 }
20058
20059
20060 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
20061 PyObject *obj;
20062 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20063 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
20064 Py_INCREF(obj);
20065 return Py_BuildValue((char *)"");
20066 }
20067 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
20068 PyObject *resultobj;
20069 wxFontList *arg1 = (wxFontList *) 0 ;
20070 wxFont *arg2 = (wxFont *) 0 ;
20071 PyObject * obj0 = 0 ;
20072 PyObject * obj1 = 0 ;
20073 char *kwnames[] = {
20074 (char *) "self",(char *) "font", NULL
20075 };
20076
20077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
20078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20079 if (SWIG_arg_fail(1)) SWIG_fail;
20080 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20081 if (SWIG_arg_fail(2)) SWIG_fail;
20082 {
20083 PyThreadState* __tstate = wxPyBeginAllowThreads();
20084 (arg1)->AddFont(arg2);
20085
20086 wxPyEndAllowThreads(__tstate);
20087 if (PyErr_Occurred()) SWIG_fail;
20088 }
20089 Py_INCREF(Py_None); resultobj = Py_None;
20090 return resultobj;
20091 fail:
20092 return NULL;
20093 }
20094
20095
20096 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
20097 PyObject *resultobj;
20098 wxFontList *arg1 = (wxFontList *) 0 ;
20099 int arg2 ;
20100 int arg3 ;
20101 int arg4 ;
20102 int arg5 ;
20103 bool arg6 = (bool) false ;
20104 wxString const &arg7_defvalue = wxPyEmptyString ;
20105 wxString *arg7 = (wxString *) &arg7_defvalue ;
20106 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
20107 wxFont *result;
20108 bool temp7 = false ;
20109 PyObject * obj0 = 0 ;
20110 PyObject * obj1 = 0 ;
20111 PyObject * obj2 = 0 ;
20112 PyObject * obj3 = 0 ;
20113 PyObject * obj4 = 0 ;
20114 PyObject * obj5 = 0 ;
20115 PyObject * obj6 = 0 ;
20116 PyObject * obj7 = 0 ;
20117 char *kwnames[] = {
20118 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
20119 };
20120
20121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20123 if (SWIG_arg_fail(1)) SWIG_fail;
20124 {
20125 arg2 = (int)(SWIG_As_int(obj1));
20126 if (SWIG_arg_fail(2)) SWIG_fail;
20127 }
20128 {
20129 arg3 = (int)(SWIG_As_int(obj2));
20130 if (SWIG_arg_fail(3)) SWIG_fail;
20131 }
20132 {
20133 arg4 = (int)(SWIG_As_int(obj3));
20134 if (SWIG_arg_fail(4)) SWIG_fail;
20135 }
20136 {
20137 arg5 = (int)(SWIG_As_int(obj4));
20138 if (SWIG_arg_fail(5)) SWIG_fail;
20139 }
20140 if (obj5) {
20141 {
20142 arg6 = (bool)(SWIG_As_bool(obj5));
20143 if (SWIG_arg_fail(6)) SWIG_fail;
20144 }
20145 }
20146 if (obj6) {
20147 {
20148 arg7 = wxString_in_helper(obj6);
20149 if (arg7 == NULL) SWIG_fail;
20150 temp7 = true;
20151 }
20152 }
20153 if (obj7) {
20154 {
20155 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
20156 if (SWIG_arg_fail(8)) SWIG_fail;
20157 }
20158 }
20159 {
20160 PyThreadState* __tstate = wxPyBeginAllowThreads();
20161 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
20162
20163 wxPyEndAllowThreads(__tstate);
20164 if (PyErr_Occurred()) SWIG_fail;
20165 }
20166 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
20167 {
20168 if (temp7)
20169 delete arg7;
20170 }
20171 return resultobj;
20172 fail:
20173 {
20174 if (temp7)
20175 delete arg7;
20176 }
20177 return NULL;
20178 }
20179
20180
20181 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
20182 PyObject *resultobj;
20183 wxFontList *arg1 = (wxFontList *) 0 ;
20184 wxFont *arg2 = (wxFont *) 0 ;
20185 PyObject * obj0 = 0 ;
20186 PyObject * obj1 = 0 ;
20187 char *kwnames[] = {
20188 (char *) "self",(char *) "font", NULL
20189 };
20190
20191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
20192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20193 if (SWIG_arg_fail(1)) SWIG_fail;
20194 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20195 if (SWIG_arg_fail(2)) SWIG_fail;
20196 {
20197 PyThreadState* __tstate = wxPyBeginAllowThreads();
20198 (arg1)->RemoveFont(arg2);
20199
20200 wxPyEndAllowThreads(__tstate);
20201 if (PyErr_Occurred()) SWIG_fail;
20202 }
20203 Py_INCREF(Py_None); resultobj = Py_None;
20204 return resultobj;
20205 fail:
20206 return NULL;
20207 }
20208
20209
20210 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20211 PyObject *resultobj;
20212 wxFontList *arg1 = (wxFontList *) 0 ;
20213 int result;
20214 PyObject * obj0 = 0 ;
20215 char *kwnames[] = {
20216 (char *) "self", NULL
20217 };
20218
20219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
20220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20221 if (SWIG_arg_fail(1)) SWIG_fail;
20222 {
20223 PyThreadState* __tstate = wxPyBeginAllowThreads();
20224 result = (int)(arg1)->GetCount();
20225
20226 wxPyEndAllowThreads(__tstate);
20227 if (PyErr_Occurred()) SWIG_fail;
20228 }
20229 {
20230 resultobj = SWIG_From_int((int)(result));
20231 }
20232 return resultobj;
20233 fail:
20234 return NULL;
20235 }
20236
20237
20238 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
20239 PyObject *obj;
20240 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20241 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
20242 Py_INCREF(obj);
20243 return Py_BuildValue((char *)"");
20244 }
20245 static int _wrap_TheFontList_set(PyObject *) {
20246 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
20247 return 1;
20248 }
20249
20250
20251 static PyObject *_wrap_TheFontList_get(void) {
20252 PyObject *pyobj;
20253
20254 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
20255 return pyobj;
20256 }
20257
20258
20259 static int _wrap_ThePenList_set(PyObject *) {
20260 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
20261 return 1;
20262 }
20263
20264
20265 static PyObject *_wrap_ThePenList_get(void) {
20266 PyObject *pyobj;
20267
20268 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
20269 return pyobj;
20270 }
20271
20272
20273 static int _wrap_TheBrushList_set(PyObject *) {
20274 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
20275 return 1;
20276 }
20277
20278
20279 static PyObject *_wrap_TheBrushList_get(void) {
20280 PyObject *pyobj;
20281
20282 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
20283 return pyobj;
20284 }
20285
20286
20287 static int _wrap_TheColourDatabase_set(PyObject *) {
20288 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
20289 return 1;
20290 }
20291
20292
20293 static PyObject *_wrap_TheColourDatabase_get(void) {
20294 PyObject *pyobj;
20295
20296 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
20297 return pyobj;
20298 }
20299
20300
20301 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
20302 PyObject *resultobj;
20303 wxEffects *result;
20304 char *kwnames[] = {
20305 NULL
20306 };
20307
20308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
20309 {
20310 PyThreadState* __tstate = wxPyBeginAllowThreads();
20311 result = (wxEffects *)new wxEffects();
20312
20313 wxPyEndAllowThreads(__tstate);
20314 if (PyErr_Occurred()) SWIG_fail;
20315 }
20316 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
20317 return resultobj;
20318 fail:
20319 return NULL;
20320 }
20321
20322
20323 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20324 PyObject *resultobj;
20325 wxEffects *arg1 = (wxEffects *) 0 ;
20326 wxColour result;
20327 PyObject * obj0 = 0 ;
20328 char *kwnames[] = {
20329 (char *) "self", NULL
20330 };
20331
20332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
20333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20334 if (SWIG_arg_fail(1)) SWIG_fail;
20335 {
20336 PyThreadState* __tstate = wxPyBeginAllowThreads();
20337 result = ((wxEffects const *)arg1)->GetHighlightColour();
20338
20339 wxPyEndAllowThreads(__tstate);
20340 if (PyErr_Occurred()) SWIG_fail;
20341 }
20342 {
20343 wxColour * resultptr;
20344 resultptr = new wxColour((wxColour &)(result));
20345 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20346 }
20347 return resultobj;
20348 fail:
20349 return NULL;
20350 }
20351
20352
20353 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20354 PyObject *resultobj;
20355 wxEffects *arg1 = (wxEffects *) 0 ;
20356 wxColour result;
20357 PyObject * obj0 = 0 ;
20358 char *kwnames[] = {
20359 (char *) "self", NULL
20360 };
20361
20362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
20363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20364 if (SWIG_arg_fail(1)) SWIG_fail;
20365 {
20366 PyThreadState* __tstate = wxPyBeginAllowThreads();
20367 result = ((wxEffects const *)arg1)->GetLightShadow();
20368
20369 wxPyEndAllowThreads(__tstate);
20370 if (PyErr_Occurred()) SWIG_fail;
20371 }
20372 {
20373 wxColour * resultptr;
20374 resultptr = new wxColour((wxColour &)(result));
20375 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20376 }
20377 return resultobj;
20378 fail:
20379 return NULL;
20380 }
20381
20382
20383 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20384 PyObject *resultobj;
20385 wxEffects *arg1 = (wxEffects *) 0 ;
20386 wxColour result;
20387 PyObject * obj0 = 0 ;
20388 char *kwnames[] = {
20389 (char *) "self", NULL
20390 };
20391
20392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
20393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20394 if (SWIG_arg_fail(1)) SWIG_fail;
20395 {
20396 PyThreadState* __tstate = wxPyBeginAllowThreads();
20397 result = ((wxEffects const *)arg1)->GetFaceColour();
20398
20399 wxPyEndAllowThreads(__tstate);
20400 if (PyErr_Occurred()) SWIG_fail;
20401 }
20402 {
20403 wxColour * resultptr;
20404 resultptr = new wxColour((wxColour &)(result));
20405 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20406 }
20407 return resultobj;
20408 fail:
20409 return NULL;
20410 }
20411
20412
20413 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20414 PyObject *resultobj;
20415 wxEffects *arg1 = (wxEffects *) 0 ;
20416 wxColour result;
20417 PyObject * obj0 = 0 ;
20418 char *kwnames[] = {
20419 (char *) "self", NULL
20420 };
20421
20422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
20423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20424 if (SWIG_arg_fail(1)) SWIG_fail;
20425 {
20426 PyThreadState* __tstate = wxPyBeginAllowThreads();
20427 result = ((wxEffects const *)arg1)->GetMediumShadow();
20428
20429 wxPyEndAllowThreads(__tstate);
20430 if (PyErr_Occurred()) SWIG_fail;
20431 }
20432 {
20433 wxColour * resultptr;
20434 resultptr = new wxColour((wxColour &)(result));
20435 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20436 }
20437 return resultobj;
20438 fail:
20439 return NULL;
20440 }
20441
20442
20443 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20444 PyObject *resultobj;
20445 wxEffects *arg1 = (wxEffects *) 0 ;
20446 wxColour result;
20447 PyObject * obj0 = 0 ;
20448 char *kwnames[] = {
20449 (char *) "self", NULL
20450 };
20451
20452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
20453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20454 if (SWIG_arg_fail(1)) SWIG_fail;
20455 {
20456 PyThreadState* __tstate = wxPyBeginAllowThreads();
20457 result = ((wxEffects const *)arg1)->GetDarkShadow();
20458
20459 wxPyEndAllowThreads(__tstate);
20460 if (PyErr_Occurred()) SWIG_fail;
20461 }
20462 {
20463 wxColour * resultptr;
20464 resultptr = new wxColour((wxColour &)(result));
20465 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20466 }
20467 return resultobj;
20468 fail:
20469 return NULL;
20470 }
20471
20472
20473 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20474 PyObject *resultobj;
20475 wxEffects *arg1 = (wxEffects *) 0 ;
20476 wxColour *arg2 = 0 ;
20477 wxColour temp2 ;
20478 PyObject * obj0 = 0 ;
20479 PyObject * obj1 = 0 ;
20480 char *kwnames[] = {
20481 (char *) "self",(char *) "c", NULL
20482 };
20483
20484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
20485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20486 if (SWIG_arg_fail(1)) SWIG_fail;
20487 {
20488 arg2 = &temp2;
20489 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20490 }
20491 {
20492 PyThreadState* __tstate = wxPyBeginAllowThreads();
20493 (arg1)->SetHighlightColour((wxColour const &)*arg2);
20494
20495 wxPyEndAllowThreads(__tstate);
20496 if (PyErr_Occurred()) SWIG_fail;
20497 }
20498 Py_INCREF(Py_None); resultobj = Py_None;
20499 return resultobj;
20500 fail:
20501 return NULL;
20502 }
20503
20504
20505 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20506 PyObject *resultobj;
20507 wxEffects *arg1 = (wxEffects *) 0 ;
20508 wxColour *arg2 = 0 ;
20509 wxColour temp2 ;
20510 PyObject * obj0 = 0 ;
20511 PyObject * obj1 = 0 ;
20512 char *kwnames[] = {
20513 (char *) "self",(char *) "c", NULL
20514 };
20515
20516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
20517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20518 if (SWIG_arg_fail(1)) SWIG_fail;
20519 {
20520 arg2 = &temp2;
20521 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20522 }
20523 {
20524 PyThreadState* __tstate = wxPyBeginAllowThreads();
20525 (arg1)->SetLightShadow((wxColour const &)*arg2);
20526
20527 wxPyEndAllowThreads(__tstate);
20528 if (PyErr_Occurred()) SWIG_fail;
20529 }
20530 Py_INCREF(Py_None); resultobj = Py_None;
20531 return resultobj;
20532 fail:
20533 return NULL;
20534 }
20535
20536
20537 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20538 PyObject *resultobj;
20539 wxEffects *arg1 = (wxEffects *) 0 ;
20540 wxColour *arg2 = 0 ;
20541 wxColour temp2 ;
20542 PyObject * obj0 = 0 ;
20543 PyObject * obj1 = 0 ;
20544 char *kwnames[] = {
20545 (char *) "self",(char *) "c", NULL
20546 };
20547
20548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
20549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20550 if (SWIG_arg_fail(1)) SWIG_fail;
20551 {
20552 arg2 = &temp2;
20553 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20554 }
20555 {
20556 PyThreadState* __tstate = wxPyBeginAllowThreads();
20557 (arg1)->SetFaceColour((wxColour const &)*arg2);
20558
20559 wxPyEndAllowThreads(__tstate);
20560 if (PyErr_Occurred()) SWIG_fail;
20561 }
20562 Py_INCREF(Py_None); resultobj = Py_None;
20563 return resultobj;
20564 fail:
20565 return NULL;
20566 }
20567
20568
20569 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20570 PyObject *resultobj;
20571 wxEffects *arg1 = (wxEffects *) 0 ;
20572 wxColour *arg2 = 0 ;
20573 wxColour temp2 ;
20574 PyObject * obj0 = 0 ;
20575 PyObject * obj1 = 0 ;
20576 char *kwnames[] = {
20577 (char *) "self",(char *) "c", NULL
20578 };
20579
20580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
20581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20582 if (SWIG_arg_fail(1)) SWIG_fail;
20583 {
20584 arg2 = &temp2;
20585 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20586 }
20587 {
20588 PyThreadState* __tstate = wxPyBeginAllowThreads();
20589 (arg1)->SetMediumShadow((wxColour const &)*arg2);
20590
20591 wxPyEndAllowThreads(__tstate);
20592 if (PyErr_Occurred()) SWIG_fail;
20593 }
20594 Py_INCREF(Py_None); resultobj = Py_None;
20595 return resultobj;
20596 fail:
20597 return NULL;
20598 }
20599
20600
20601 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20602 PyObject *resultobj;
20603 wxEffects *arg1 = (wxEffects *) 0 ;
20604 wxColour *arg2 = 0 ;
20605 wxColour temp2 ;
20606 PyObject * obj0 = 0 ;
20607 PyObject * obj1 = 0 ;
20608 char *kwnames[] = {
20609 (char *) "self",(char *) "c", NULL
20610 };
20611
20612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
20613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20614 if (SWIG_arg_fail(1)) SWIG_fail;
20615 {
20616 arg2 = &temp2;
20617 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20618 }
20619 {
20620 PyThreadState* __tstate = wxPyBeginAllowThreads();
20621 (arg1)->SetDarkShadow((wxColour const &)*arg2);
20622
20623 wxPyEndAllowThreads(__tstate);
20624 if (PyErr_Occurred()) SWIG_fail;
20625 }
20626 Py_INCREF(Py_None); resultobj = Py_None;
20627 return resultobj;
20628 fail:
20629 return NULL;
20630 }
20631
20632
20633 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20634 PyObject *resultobj;
20635 wxEffects *arg1 = (wxEffects *) 0 ;
20636 wxColour *arg2 = 0 ;
20637 wxColour *arg3 = 0 ;
20638 wxColour *arg4 = 0 ;
20639 wxColour *arg5 = 0 ;
20640 wxColour *arg6 = 0 ;
20641 wxColour temp2 ;
20642 wxColour temp3 ;
20643 wxColour temp4 ;
20644 wxColour temp5 ;
20645 wxColour temp6 ;
20646 PyObject * obj0 = 0 ;
20647 PyObject * obj1 = 0 ;
20648 PyObject * obj2 = 0 ;
20649 PyObject * obj3 = 0 ;
20650 PyObject * obj4 = 0 ;
20651 PyObject * obj5 = 0 ;
20652 char *kwnames[] = {
20653 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
20654 };
20655
20656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
20657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20658 if (SWIG_arg_fail(1)) SWIG_fail;
20659 {
20660 arg2 = &temp2;
20661 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20662 }
20663 {
20664 arg3 = &temp3;
20665 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20666 }
20667 {
20668 arg4 = &temp4;
20669 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
20670 }
20671 {
20672 arg5 = &temp5;
20673 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
20674 }
20675 {
20676 arg6 = &temp6;
20677 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
20678 }
20679 {
20680 PyThreadState* __tstate = wxPyBeginAllowThreads();
20681 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
20682
20683 wxPyEndAllowThreads(__tstate);
20684 if (PyErr_Occurred()) SWIG_fail;
20685 }
20686 Py_INCREF(Py_None); resultobj = Py_None;
20687 return resultobj;
20688 fail:
20689 return NULL;
20690 }
20691
20692
20693 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
20694 PyObject *resultobj;
20695 wxEffects *arg1 = (wxEffects *) 0 ;
20696 wxDC *arg2 = 0 ;
20697 wxRect *arg3 = 0 ;
20698 int arg4 = (int) 1 ;
20699 wxRect temp3 ;
20700 PyObject * obj0 = 0 ;
20701 PyObject * obj1 = 0 ;
20702 PyObject * obj2 = 0 ;
20703 PyObject * obj3 = 0 ;
20704 char *kwnames[] = {
20705 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
20706 };
20707
20708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20710 if (SWIG_arg_fail(1)) SWIG_fail;
20711 {
20712 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20713 if (SWIG_arg_fail(2)) SWIG_fail;
20714 if (arg2 == NULL) {
20715 SWIG_null_ref("wxDC");
20716 }
20717 if (SWIG_arg_fail(2)) SWIG_fail;
20718 }
20719 {
20720 arg3 = &temp3;
20721 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
20722 }
20723 if (obj3) {
20724 {
20725 arg4 = (int)(SWIG_As_int(obj3));
20726 if (SWIG_arg_fail(4)) SWIG_fail;
20727 }
20728 }
20729 {
20730 PyThreadState* __tstate = wxPyBeginAllowThreads();
20731 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
20732
20733 wxPyEndAllowThreads(__tstate);
20734 if (PyErr_Occurred()) SWIG_fail;
20735 }
20736 Py_INCREF(Py_None); resultobj = Py_None;
20737 return resultobj;
20738 fail:
20739 return NULL;
20740 }
20741
20742
20743 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
20744 PyObject *resultobj;
20745 wxEffects *arg1 = (wxEffects *) 0 ;
20746 wxRect *arg2 = 0 ;
20747 wxDC *arg3 = 0 ;
20748 wxBitmap *arg4 = 0 ;
20749 bool result;
20750 wxRect temp2 ;
20751 PyObject * obj0 = 0 ;
20752 PyObject * obj1 = 0 ;
20753 PyObject * obj2 = 0 ;
20754 PyObject * obj3 = 0 ;
20755 char *kwnames[] = {
20756 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
20757 };
20758
20759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20761 if (SWIG_arg_fail(1)) SWIG_fail;
20762 {
20763 arg2 = &temp2;
20764 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20765 }
20766 {
20767 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20768 if (SWIG_arg_fail(3)) SWIG_fail;
20769 if (arg3 == NULL) {
20770 SWIG_null_ref("wxDC");
20771 }
20772 if (SWIG_arg_fail(3)) SWIG_fail;
20773 }
20774 {
20775 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
20776 if (SWIG_arg_fail(4)) SWIG_fail;
20777 if (arg4 == NULL) {
20778 SWIG_null_ref("wxBitmap");
20779 }
20780 if (SWIG_arg_fail(4)) SWIG_fail;
20781 }
20782 {
20783 PyThreadState* __tstate = wxPyBeginAllowThreads();
20784 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
20785
20786 wxPyEndAllowThreads(__tstate);
20787 if (PyErr_Occurred()) SWIG_fail;
20788 }
20789 {
20790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20791 }
20792 return resultobj;
20793 fail:
20794 return NULL;
20795 }
20796
20797
20798 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
20799 PyObject *obj;
20800 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20801 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
20802 Py_INCREF(obj);
20803 return Py_BuildValue((char *)"");
20804 }
20805 static PyMethodDef SwigMethods[] = {
20806 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20807 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20808 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20809 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20810 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
20811 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
20812 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20813 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
20814 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20815 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20816 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
20817 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
20818 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
20819 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20820 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20821 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20822 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20823 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20824 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20825 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20826 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20827 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20828 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
20829 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20830 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20831 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20832 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20833 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
20834 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20835 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
20836 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20837 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20838 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20839 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20840 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20841 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20842 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20843 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20844 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20845 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20846 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20847 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20848 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20849 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20850 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20851 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20852 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20853 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20854 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
20855 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20856 { (char *)"new_BrushFromBitmap", (PyCFunction) _wrap_new_BrushFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20857 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20858 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20859 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20860 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20861 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20862 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20863 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20864 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
20865 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20866 { (char *)"Brush_MacGetTheme", (PyCFunction) _wrap_Brush_MacGetTheme, METH_VARARGS | METH_KEYWORDS, NULL},
20867 { (char *)"Brush_MacSetTheme", (PyCFunction) _wrap_Brush_MacSetTheme, METH_VARARGS | METH_KEYWORDS, NULL},
20868 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
20869 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20870 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20871 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20872 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20873 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20874 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20875 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
20876 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20877 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20878 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20879 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20880 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20881 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
20882 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20883 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20884 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
20885 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20886 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
20887 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
20888 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
20889 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20890 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20891 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20892 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20893 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20894 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20895 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20896 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
20897 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
20898 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
20899 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20900 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20901 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20902 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20903 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20904 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20905 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20906 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20907 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20908 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20909 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20910 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20911 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20912 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20913 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
20914 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20915 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20916 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20917 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20918 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20919 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20920 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20921 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
20922 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20923 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20924 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20925 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20926 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20927 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20928 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20929 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
20930 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20931 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20932 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20933 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20934 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20935 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
20936 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20937 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20938 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20939 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
20940 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20941 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
20942 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
20943 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
20944 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20945 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
20946 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
20947 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
20948 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
20949 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
20950 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20951 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
20952 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
20953 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
20954 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20955 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
20956 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
20957 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20958 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
20959 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
20960 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20961 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20962 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20963 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20964 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
20965 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20966 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20967 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
20968 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
20969 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
20970 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20971 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
20972 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20973 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
20974 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
20975 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
20976 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
20977 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
20978 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
20979 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20980 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20981 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
20982 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
20983 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20984 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20985 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20986 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20987 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20988 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20989 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20990 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20991 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20992 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20993 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20994 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20995 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20996 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20997 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20998 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20999 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
21000 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21001 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21002 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
21003 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
21004 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
21005 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
21006 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
21007 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21008 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21009 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
21010 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
21011 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
21012 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21013 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21014 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21015 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21016 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21017 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21018 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21019 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
21020 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21021 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21022 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
21023 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
21024 { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
21025 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21026 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21027 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21028 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
21029 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
21030 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
21031 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
21032 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21033 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21034 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21035 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
21036 { (char *)"new_FFont", (PyCFunction) _wrap_new_FFont, METH_VARARGS | METH_KEYWORDS, NULL},
21037 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21038 { (char *)"new_FFontFromPixelSize", (PyCFunction) _wrap_new_FFontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21039 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21040 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21041 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21042 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21043 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21044 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
21045 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21046 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21047 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21048 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21049 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21050 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21051 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21052 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21053 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21054 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21055 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21056 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21057 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21058 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21059 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21060 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21061 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21062 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21063 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21064 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
21065 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21066 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
21067 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
21068 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
21069 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21070 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21071 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21072 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21073 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
21074 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21075 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21076 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21077 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21078 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21079 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21080 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21081 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
21082 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
21083 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
21084 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
21085 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
21086 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
21087 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
21088 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
21089 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21090 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21091 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
21092 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
21093 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21094 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21095 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21096 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21097 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21098 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21099 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
21100 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
21101 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
21102 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
21103 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
21104 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21105 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
21106 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21107 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21108 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
21109 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
21110 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
21111 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21112 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
21113 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21114 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21115 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21116 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
21117 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21118 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21119 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
21120 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
21121 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
21122 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21123 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21124 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
21125 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21126 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21127 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21128 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
21129 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21130 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
21131 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21132 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
21133 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21134 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
21135 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
21136 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
21137 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21138 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21139 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21140 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21141 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21142 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21143 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21144 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21145 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21146 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
21147 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21148 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
21149 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
21150 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21151 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21152 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21153 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21154 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21155 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
21156 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21157 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
21158 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21159 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
21160 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21161 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21162 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21163 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21164 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21165 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
21166 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
21167 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21168 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21169 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
21170 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21171 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21172 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21173 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
21174 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
21175 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21176 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21177 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21178 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21179 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21180 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21181 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21182 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21183 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21184 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21185 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21186 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21187 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21188 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21189 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
21190 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21191 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21192 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
21193 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21194 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
21195 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
21196 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21197 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21198 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
21199 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
21200 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21201 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21202 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21203 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21204 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21205 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
21206 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21207 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21208 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21209 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21210 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21211 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21212 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21213 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21214 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21215 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21216 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21217 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21218 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21219 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21220 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21221 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21222 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21223 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21224 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21225 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21226 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21227 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21228 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21229 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21230 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
21231 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21232 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21233 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21234 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21235 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21236 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21237 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
21238 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
21239 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
21240 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
21241 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21242 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
21243 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
21244 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
21245 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
21246 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
21247 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
21248 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
21249 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
21250 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
21251 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
21252 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
21253 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
21254 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
21255 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
21256 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
21257 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21258 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
21259 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
21260 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
21261 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21262 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21263 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
21264 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
21265 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
21266 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21267 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
21268 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
21269 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
21270 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
21271 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
21272 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
21273 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21274 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21275 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21276 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21277 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
21278 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21279 { (char *)"delete_MetaFile", (PyCFunction) _wrap_delete_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21280 { (char *)"MetaFile_Ok", (PyCFunction) _wrap_MetaFile_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21281 { (char *)"MetaFile_SetClipboard", (PyCFunction) _wrap_MetaFile_SetClipboard, METH_VARARGS | METH_KEYWORDS, NULL},
21282 { (char *)"MetaFile_GetSize", (PyCFunction) _wrap_MetaFile_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21283 { (char *)"MetaFile_GetWidth", (PyCFunction) _wrap_MetaFile_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21284 { (char *)"MetaFile_GetHeight", (PyCFunction) _wrap_MetaFile_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21285 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
21286 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
21287 { (char *)"MetaFileDC_Close", (PyCFunction) _wrap_MetaFileDC_Close, METH_VARARGS | METH_KEYWORDS, NULL},
21288 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
21289 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
21290 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
21291 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21292 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21293 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
21294 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
21295 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21296 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21297 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21298 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
21299 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
21300 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
21301 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
21302 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
21303 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21304 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
21305 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
21306 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
21307 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
21308 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21309 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
21310 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21311 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21312 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21313 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21314 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
21315 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21316 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21317 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
21318 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
21319 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
21320 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
21321 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
21322 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
21323 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
21324 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
21325 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21326 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
21327 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
21328 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21329 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21330 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21331 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21332 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21333 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21334 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21335 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21336 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21337 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21338 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21339 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
21340 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21341 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
21342 { NULL, NULL, 0, NULL }
21343 };
21344
21345
21346 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21347
21348 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
21349 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
21350 }
21351 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
21352 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
21353 }
21354 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
21355 return (void *)((wxGDIObject *) ((wxIcon *) x));
21356 }
21357 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
21358 return (void *)((wxGDIObject *) ((wxPalette *) x));
21359 }
21360 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
21361 return (void *)((wxGDIObject *) ((wxPen *) x));
21362 }
21363 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
21364 return (void *)((wxGDIObject *) ((wxFont *) x));
21365 }
21366 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
21367 return (void *)((wxGDIObject *) ((wxCursor *) x));
21368 }
21369 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
21370 return (void *)((wxGDIObject *) ((wxBitmap *) x));
21371 }
21372 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
21373 return (void *)((wxGDIObject *) ((wxRegion *) x));
21374 }
21375 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
21376 return (void *)((wxGDIObject *) ((wxBrush *) x));
21377 }
21378 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
21379 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
21380 }
21381 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
21382 return (void *)((wxDC *) ((wxScreenDC *) x));
21383 }
21384 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
21385 return (void *)((wxDC *) ((wxMirrorDC *) x));
21386 }
21387 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
21388 return (void *)((wxDC *) ((wxMemoryDC *) x));
21389 }
21390 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
21391 return (void *)((wxDC *) ((wxWindowDC *) x));
21392 }
21393 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
21394 return (void *)((wxDC *) ((wxMetaFileDC *) x));
21395 }
21396 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
21397 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21398 }
21399 static void *_p_wxClientDCTo_p_wxDC(void *x) {
21400 return (void *)((wxDC *) ((wxClientDC *) x));
21401 }
21402 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
21403 return (void *)((wxDC *) ((wxPaintDC *) x));
21404 }
21405 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
21406 return (void *)((wxDC *) ((wxPostScriptDC *) x));
21407 }
21408 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
21409 return (void *)((wxDC *) ((wxPrinterDC *) x));
21410 }
21411 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
21412 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
21413 }
21414 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21415 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21416 }
21417 static void *_p_wxPenTo_p_wxObject(void *x) {
21418 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
21419 }
21420 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
21421 return (void *)((wxObject *) ((wxRegionIterator *) x));
21422 }
21423 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21424 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21425 }
21426 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21427 return (void *)((wxObject *) ((wxSizerItem *) x));
21428 }
21429 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
21430 return (void *)((wxObject *) ((wxColourDatabase *) x));
21431 }
21432 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21433 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21434 }
21435 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21436 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21437 }
21438 static void *_p_wxIconTo_p_wxObject(void *x) {
21439 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
21440 }
21441 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21442 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21443 }
21444 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21445 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21446 }
21447 static void *_p_wxSizerTo_p_wxObject(void *x) {
21448 return (void *)((wxObject *) ((wxSizer *) x));
21449 }
21450 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21451 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21452 }
21453 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21454 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21455 }
21456 static void *_p_wxPenListTo_p_wxObject(void *x) {
21457 return (void *)((wxObject *) ((wxPenList *) x));
21458 }
21459 static void *_p_wxEventTo_p_wxObject(void *x) {
21460 return (void *)((wxObject *) ((wxEvent *) x));
21461 }
21462 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21463 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21464 }
21465 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21466 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21467 }
21468 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21469 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21470 }
21471 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21472 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21473 }
21474 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21475 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21476 }
21477 static void *_p_wxDCTo_p_wxObject(void *x) {
21478 return (void *)((wxObject *) ((wxDC *) x));
21479 }
21480 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21481 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21482 }
21483 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21484 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21485 }
21486 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21487 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21488 }
21489 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21490 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21491 }
21492 static void *_p_wxControlTo_p_wxObject(void *x) {
21493 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21494 }
21495 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21496 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21497 }
21498 static void *_p_wxClientDCTo_p_wxObject(void *x) {
21499 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
21500 }
21501 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21502 return (void *)((wxObject *) ((wxFSFile *) x));
21503 }
21504 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
21505 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
21506 }
21507 static void *_p_wxRegionTo_p_wxObject(void *x) {
21508 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
21509 }
21510 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21511 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21512 }
21513 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
21514 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
21515 }
21516 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
21517 return (void *)((wxObject *) ((wxGDIObject *) x));
21518 }
21519 static void *_p_wxEffectsTo_p_wxObject(void *x) {
21520 return (void *)((wxObject *) ((wxEffects *) x));
21521 }
21522 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21523 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21524 }
21525 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21526 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21527 }
21528 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
21529 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
21530 }
21531 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21532 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21533 }
21534 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21535 return (void *)((wxObject *) ((wxMenuItem *) x));
21536 }
21537 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21538 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21539 }
21540 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21541 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21542 }
21543 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21544 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21545 }
21546 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21547 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21548 }
21549 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21550 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21551 }
21552 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21553 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21554 }
21555 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21556 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21557 }
21558 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21559 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21560 }
21561 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21562 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21563 }
21564 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21565 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21566 }
21567 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21568 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21569 }
21570 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21571 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21572 }
21573 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21574 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21575 }
21576 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21577 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21578 }
21579 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21580 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21581 }
21582 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21583 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21584 }
21585 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21586 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21587 }
21588 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21589 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21590 }
21591 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21592 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21593 }
21594 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21595 return (void *)((wxObject *) ((wxImageHandler *) x));
21596 }
21597 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21598 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21599 }
21600 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21601 return (void *)((wxObject *) ((wxEvtHandler *) x));
21602 }
21603 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
21604 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21605 }
21606 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
21607 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
21608 }
21609 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
21610 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
21611 }
21612 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
21613 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
21614 }
21615 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21616 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21617 }
21618 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21619 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21620 }
21621 static void *_p_wxImageTo_p_wxObject(void *x) {
21622 return (void *)((wxObject *) ((wxImage *) x));
21623 }
21624 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21625 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21626 }
21627 static void *_p_wxPaletteTo_p_wxObject(void *x) {
21628 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
21629 }
21630 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
21631 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
21632 }
21633 static void *_p_wxImageListTo_p_wxObject(void *x) {
21634 return (void *)((wxObject *) ((wxImageList *) x));
21635 }
21636 static void *_p_wxCursorTo_p_wxObject(void *x) {
21637 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
21638 }
21639 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
21640 return (void *)((wxObject *) ((wxEncodingConverter *) x));
21641 }
21642 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
21643 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
21644 }
21645 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21646 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21647 }
21648 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21649 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21650 }
21651 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21652 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21653 }
21654 static void *_p_wxWindowTo_p_wxObject(void *x) {
21655 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21656 }
21657 static void *_p_wxMenuTo_p_wxObject(void *x) {
21658 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21659 }
21660 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21661 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21662 }
21663 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
21664 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
21665 }
21666 static void *_p_wxBrushListTo_p_wxObject(void *x) {
21667 return (void *)((wxObject *) ((wxBrushList *) x));
21668 }
21669 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21670 return (void *)((wxObject *) ((wxFileSystem *) x));
21671 }
21672 static void *_p_wxBitmapTo_p_wxObject(void *x) {
21673 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
21674 }
21675 static void *_p_wxMaskTo_p_wxObject(void *x) {
21676 return (void *)((wxObject *) ((wxMask *) x));
21677 }
21678 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21679 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21680 }
21681 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21682 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21683 }
21684 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21685 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21686 }
21687 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21688 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21689 }
21690 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21691 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21692 }
21693 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21694 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21695 }
21696 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21697 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21698 }
21699 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21700 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21701 }
21702 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21703 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21704 }
21705 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21706 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21707 }
21708 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21709 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21710 }
21711 static void *_p_wxFontTo_p_wxObject(void *x) {
21712 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
21713 }
21714 static void *_p_wxBrushTo_p_wxObject(void *x) {
21715 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
21716 }
21717 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
21718 return (void *)((wxObject *) ((wxMetaFile *) x));
21719 }
21720 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21721 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21722 }
21723 static void *_p_wxColourTo_p_wxObject(void *x) {
21724 return (void *)((wxObject *) ((wxColour *) x));
21725 }
21726 static void *_p_wxFontListTo_p_wxObject(void *x) {
21727 return (void *)((wxObject *) ((wxFontList *) x));
21728 }
21729 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21730 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21731 }
21732 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21733 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21734 }
21735 static void *_p_wxControlTo_p_wxWindow(void *x) {
21736 return (void *)((wxWindow *) ((wxControl *) x));
21737 }
21738 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21739 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21740 }
21741 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
21742 return (void *)((wxWindow *) ((wxMenuBar *) x));
21743 }
21744 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}};
21745 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}};
21746 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}};
21747 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}};
21748 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}};
21749 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}};
21750 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}};
21751 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}};
21752 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}};
21753 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}};
21754 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}};
21755 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}};
21756 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}};
21757 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}};
21758 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}};
21759 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}};
21760 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}};
21761 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}};
21762 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}};
21763 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}};
21764 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}};
21765 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}};
21766 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}};
21767 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxRegionIterator", _p_wxRegionIteratorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPen", _p_wxPenTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColourDatabase", _p_wxColourDatabaseTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPenList", _p_wxPenListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMask", _p_wxMaskTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFont", _p_wxFontTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClientDC", _p_wxClientDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMemoryDC", _p_wxMemoryDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxRegion", _p_wxRegionTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDC", _p_wxDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIcon", _p_wxIconTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDC", _p_wxWindowDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGDIObject", _p_wxGDIObjectTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEffects", _p_wxEffectsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPostScriptDC", _p_wxPostScriptDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintDC", _p_wxPaintDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBufferedPaintDC", _p_wxBufferedPaintDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrinterDC", _p_wxPrinterDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScreenDC", _p_wxScreenDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBufferedDC", _p_wxBufferedDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPalette", _p_wxPaletteTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageList", _p_wxImageListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCursor", _p_wxCursorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxMirrorDC", _p_wxMirrorDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEncodingConverter", _p_wxEncodingConverterTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMetaFileDC", _p_wxMetaFileDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBrushList", _p_wxBrushListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBitmap", _p_wxBitmapTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBrush", _p_wxBrushTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMetaFile", _p_wxMetaFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColour", _p_wxColourTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFontList", _p_wxFontListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
21768 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}};
21769 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}};
21770 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}};
21771 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}};
21772 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}};
21773 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}};
21774 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}};
21775 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}};
21776 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}};
21777 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}};
21778 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}};
21779 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}};
21780 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}};
21781 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}};
21782 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}};
21783 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}};
21784 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}};
21785 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}};
21786 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}};
21787 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}};
21788 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}};
21789 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}};
21790 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}};
21791 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}};
21792 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}};
21793 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}};
21794 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}};
21795 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}};
21796 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}};
21797 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}};
21798 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}};
21799 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}};
21800 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}};
21801 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}};
21802 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}};
21803 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}};
21804 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}};
21805 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}};
21806
21807 static swig_type_info *swig_types_initial[] = {
21808 _swigt__p_wxPostScriptDC,
21809 _swigt__p_wxBrush,
21810 _swigt__p_wxColour,
21811 _swigt__p_wxDC,
21812 _swigt__p_wxMirrorDC,
21813 _swigt__p_form_ops_t,
21814 _swigt__p_wxDuplexMode,
21815 _swigt__p_wxPyFontEnumerator,
21816 _swigt__p_char,
21817 _swigt__p_wxIconLocation,
21818 _swigt__p_wxImage,
21819 _swigt__p_wxMetaFileDC,
21820 _swigt__p_wxMask,
21821 _swigt__p_wxSize,
21822 _swigt__p_wxFont,
21823 _swigt__p_wxWindow,
21824 _swigt__p_double,
21825 _swigt__p_wxMemoryDC,
21826 _swigt__p_wxFontMapper,
21827 _swigt__p_wxEffects,
21828 _swigt__p_wxNativeEncodingInfo,
21829 _swigt__p_wxPalette,
21830 _swigt__p_wxBitmap,
21831 _swigt__p_wxObject,
21832 _swigt__p_wxRegionIterator,
21833 _swigt__p_wxRect,
21834 _swigt__p_wxPaperSize,
21835 _swigt__p_wxString,
21836 _swigt__unsigned_int,
21837 _swigt__p_unsigned_int,
21838 _swigt__p_wxPrinterDC,
21839 _swigt__p_wxIconBundle,
21840 _swigt__p_wxPoint,
21841 _swigt__p_wxDash,
21842 _swigt__p_wxScreenDC,
21843 _swigt__p_wxCursor,
21844 _swigt__p_wxClientDC,
21845 _swigt__p_wxBufferedDC,
21846 _swigt__p_wxImageList,
21847 _swigt__p_unsigned_char,
21848 _swigt__p_wxGDIObject,
21849 _swigt__p_wxIcon,
21850 _swigt__p_wxLocale,
21851 _swigt__ptrdiff_t,
21852 _swigt__std__ptrdiff_t,
21853 _swigt__p_wxRegion,
21854 _swigt__p_wxConfigBase,
21855 _swigt__p_wxLanguageInfo,
21856 _swigt__p_wxWindowDC,
21857 _swigt__p_wxPrintData,
21858 _swigt__p_wxBrushList,
21859 _swigt__p_wxFontList,
21860 _swigt__p_wxPen,
21861 _swigt__p_wxBufferedPaintDC,
21862 _swigt__p_wxPaintDC,
21863 _swigt__p_wxPenList,
21864 _swigt__p_int,
21865 _swigt__p_wxMetaFile,
21866 _swigt__p_unsigned_long,
21867 _swigt__p_wxNativeFontInfo,
21868 _swigt__p_wxEncodingConverter,
21869 _swigt__p_wxColourDatabase,
21870 0
21871 };
21872
21873
21874 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
21875
21876 static swig_const_info swig_const_table[] = {
21877 {0, 0, 0, 0.0, 0, 0}};
21878
21879 #ifdef __cplusplus
21880 }
21881 #endif
21882
21883
21884 #ifdef __cplusplus
21885 extern "C" {
21886 #endif
21887
21888 /* Python-specific SWIG API */
21889 #define SWIG_newvarlink() SWIG_Python_newvarlink()
21890 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
21891 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
21892
21893 /* -----------------------------------------------------------------------------
21894 * global variable support code.
21895 * ----------------------------------------------------------------------------- */
21896
21897 typedef struct swig_globalvar {
21898 char *name; /* Name of global variable */
21899 PyObject *(*get_attr)(); /* Return the current value */
21900 int (*set_attr)(PyObject *); /* Set the value */
21901 struct swig_globalvar *next;
21902 } swig_globalvar;
21903
21904 typedef struct swig_varlinkobject {
21905 PyObject_HEAD
21906 swig_globalvar *vars;
21907 } swig_varlinkobject;
21908
21909 static PyObject *
21910 swig_varlink_repr(swig_varlinkobject *v) {
21911 v = v;
21912 return PyString_FromString("<Swig global variables>");
21913 }
21914
21915 static int
21916 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
21917 swig_globalvar *var;
21918 flags = flags;
21919 fprintf(fp,"Swig global variables { ");
21920 for (var = v->vars; var; var=var->next) {
21921 fprintf(fp,"%s", var->name);
21922 if (var->next) fprintf(fp,", ");
21923 }
21924 fprintf(fp," }\n");
21925 return 0;
21926 }
21927
21928 static PyObject *
21929 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
21930 swig_globalvar *var = v->vars;
21931 while (var) {
21932 if (strcmp(var->name,n) == 0) {
21933 return (*var->get_attr)();
21934 }
21935 var = var->next;
21936 }
21937 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21938 return NULL;
21939 }
21940
21941 static int
21942 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
21943 swig_globalvar *var = v->vars;
21944 while (var) {
21945 if (strcmp(var->name,n) == 0) {
21946 return (*var->set_attr)(p);
21947 }
21948 var = var->next;
21949 }
21950 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21951 return 1;
21952 }
21953
21954 static PyTypeObject varlinktype = {
21955 PyObject_HEAD_INIT(0)
21956 0, /* Number of items in variable part (ob_size) */
21957 (char *)"swigvarlink", /* Type name (tp_name) */
21958 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
21959 0, /* Itemsize (tp_itemsize) */
21960 0, /* Deallocator (tp_dealloc) */
21961 (printfunc) swig_varlink_print, /* Print (tp_print) */
21962 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
21963 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
21964 0, /* tp_compare */
21965 (reprfunc) swig_varlink_repr, /* tp_repr */
21966 0, /* tp_as_number */
21967 0, /* tp_as_sequence */
21968 0, /* tp_as_mapping */
21969 0, /* tp_hash */
21970 0, /* tp_call */
21971 0, /* tp_str */
21972 0, /* tp_getattro */
21973 0, /* tp_setattro */
21974 0, /* tp_as_buffer */
21975 0, /* tp_flags */
21976 0, /* tp_doc */
21977 #if PY_VERSION_HEX >= 0x02000000
21978 0, /* tp_traverse */
21979 0, /* tp_clear */
21980 #endif
21981 #if PY_VERSION_HEX >= 0x02010000
21982 0, /* tp_richcompare */
21983 0, /* tp_weaklistoffset */
21984 #endif
21985 #if PY_VERSION_HEX >= 0x02020000
21986 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
21987 #endif
21988 #if PY_VERSION_HEX >= 0x02030000
21989 0, /* tp_del */
21990 #endif
21991 #ifdef COUNT_ALLOCS
21992 0,0,0,0 /* tp_alloc -> tp_next */
21993 #endif
21994 };
21995
21996 /* Create a variable linking object for use later */
21997 static PyObject *
21998 SWIG_Python_newvarlink(void) {
21999 swig_varlinkobject *result = 0;
22000 result = PyMem_NEW(swig_varlinkobject,1);
22001 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
22002 result->ob_type = &varlinktype;
22003 result->vars = 0;
22004 result->ob_refcnt = 0;
22005 Py_XINCREF((PyObject *) result);
22006 return ((PyObject*) result);
22007 }
22008
22009 static void
22010 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22011 swig_varlinkobject *v;
22012 swig_globalvar *gv;
22013 v= (swig_varlinkobject *) p;
22014 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22015 gv->name = (char *) malloc(strlen(name)+1);
22016 strcpy(gv->name,name);
22017 gv->get_attr = get_attr;
22018 gv->set_attr = set_attr;
22019 gv->next = v->vars;
22020 v->vars = gv;
22021 }
22022
22023 /* -----------------------------------------------------------------------------
22024 * constants/methods manipulation
22025 * ----------------------------------------------------------------------------- */
22026
22027 /* Install Constants */
22028 static void
22029 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22030 PyObject *obj = 0;
22031 size_t i;
22032 for (i = 0; constants[i].type; i++) {
22033 switch(constants[i].type) {
22034 case SWIG_PY_INT:
22035 obj = PyInt_FromLong(constants[i].lvalue);
22036 break;
22037 case SWIG_PY_FLOAT:
22038 obj = PyFloat_FromDouble(constants[i].dvalue);
22039 break;
22040 case SWIG_PY_STRING:
22041 if (constants[i].pvalue) {
22042 obj = PyString_FromString((char *) constants[i].pvalue);
22043 } else {
22044 Py_INCREF(Py_None);
22045 obj = Py_None;
22046 }
22047 break;
22048 case SWIG_PY_POINTER:
22049 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22050 break;
22051 case SWIG_PY_BINARY:
22052 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22053 break;
22054 default:
22055 obj = 0;
22056 break;
22057 }
22058 if (obj) {
22059 PyDict_SetItemString(d,constants[i].name,obj);
22060 Py_DECREF(obj);
22061 }
22062 }
22063 }
22064
22065 /* -----------------------------------------------------------------------------*/
22066 /* Fix SwigMethods to carry the callback ptrs when needed */
22067 /* -----------------------------------------------------------------------------*/
22068
22069 static void
22070 SWIG_Python_FixMethods(PyMethodDef *methods,
22071 swig_const_info *const_table,
22072 swig_type_info **types,
22073 swig_type_info **types_initial) {
22074 size_t i;
22075 for (i = 0; methods[i].ml_name; ++i) {
22076 char *c = methods[i].ml_doc;
22077 if (c && (c = strstr(c, "swig_ptr: "))) {
22078 int j;
22079 swig_const_info *ci = 0;
22080 char *name = c + 10;
22081 for (j = 0; const_table[j].type; j++) {
22082 if (strncmp(const_table[j].name, name,
22083 strlen(const_table[j].name)) == 0) {
22084 ci = &(const_table[j]);
22085 break;
22086 }
22087 }
22088 if (ci) {
22089 size_t shift = (ci->ptype) - types;
22090 swig_type_info *ty = types_initial[shift];
22091 size_t ldoc = (c - methods[i].ml_doc);
22092 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22093 char *ndoc = (char*)malloc(ldoc + lptr + 10);
22094 char *buff = ndoc;
22095 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
22096 strncpy(buff, methods[i].ml_doc, ldoc);
22097 buff += ldoc;
22098 strncpy(buff, "swig_ptr: ", 10);
22099 buff += 10;
22100 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22101 methods[i].ml_doc = ndoc;
22102 }
22103 }
22104 }
22105 }
22106
22107 /* -----------------------------------------------------------------------------*
22108 * Initialize type list
22109 * -----------------------------------------------------------------------------*/
22110
22111 #if PY_MAJOR_VERSION < 2
22112 /* PyModule_AddObject function was introduced in Python 2.0. The following function
22113 is copied out of Python/modsupport.c in python version 2.3.4 */
22114 static int
22115 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
22116 {
22117 PyObject *dict;
22118 if (!PyModule_Check(m)) {
22119 PyErr_SetString(PyExc_TypeError,
22120 "PyModule_AddObject() needs module as first arg");
22121 return -1;
22122 }
22123 if (!o) {
22124 PyErr_SetString(PyExc_TypeError,
22125 "PyModule_AddObject() needs non-NULL value");
22126 return -1;
22127 }
22128
22129 dict = PyModule_GetDict(m);
22130 if (dict == NULL) {
22131 /* Internal error -- modules must have a dict! */
22132 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
22133 PyModule_GetName(m));
22134 return -1;
22135 }
22136 if (PyDict_SetItemString(dict, name, o))
22137 return -1;
22138 Py_DECREF(o);
22139 return 0;
22140 }
22141 #endif
22142
22143 static swig_type_info **
22144 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
22145 static PyMethodDef swig_empty_runtime_method_table[] = {
22146 {
22147 NULL, NULL, 0, NULL
22148 }
22149 };/* Sentinel */
22150
22151 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
22152 swig_empty_runtime_method_table);
22153 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
22154 if (pointer && module) {
22155 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
22156 }
22157 return type_list_handle;
22158 }
22159
22160 static swig_type_info **
22161 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
22162 swig_type_info **type_pointer;
22163
22164 /* first check if module already created */
22165 type_pointer = SWIG_Python_GetTypeListHandle();
22166 if (type_pointer) {
22167 return type_pointer;
22168 } else {
22169 /* create a new module and variable */
22170 return SWIG_Python_SetTypeListHandle(type_list_handle);
22171 }
22172 }
22173
22174 #ifdef __cplusplus
22175 }
22176 #endif
22177
22178 /* -----------------------------------------------------------------------------*
22179 * Partial Init method
22180 * -----------------------------------------------------------------------------*/
22181
22182 #ifdef SWIG_LINK_RUNTIME
22183 #ifdef __cplusplus
22184 extern "C"
22185 #endif
22186 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
22187 #endif
22188
22189 #ifdef __cplusplus
22190 extern "C"
22191 #endif
22192 SWIGEXPORT(void) SWIG_init(void) {
22193 static PyObject *SWIG_globals = 0;
22194 static int typeinit = 0;
22195 PyObject *m, *d;
22196 int i;
22197 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
22198
22199 /* Fix SwigMethods to carry the callback ptrs when needed */
22200 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
22201
22202 m = Py_InitModule((char *) SWIG_name, SwigMethods);
22203 d = PyModule_GetDict(m);
22204
22205 if (!typeinit) {
22206 #ifdef SWIG_LINK_RUNTIME
22207 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
22208 #else
22209 # ifndef SWIG_STATIC_RUNTIME
22210 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
22211 # endif
22212 #endif
22213 for (i = 0; swig_types_initial[i]; i++) {
22214 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
22215 }
22216 typeinit = 1;
22217 }
22218 SWIG_InstallConstants(d,swig_const_table);
22219
22220 {
22221 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
22222 }
22223 {
22224 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
22225 }
22226 {
22227 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
22228 }
22229 {
22230 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
22231 }
22232 {
22233 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
22234 }
22235 {
22236 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
22237 }
22238 {
22239 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
22240 }
22241 {
22242 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
22243 }
22244 {
22245 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
22246 }
22247 {
22248 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
22249 }
22250 {
22251 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
22252 }
22253 {
22254 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
22255 }
22256 {
22257 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
22258 }
22259 {
22260 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
22261 }
22262 {
22263 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
22264 }
22265 {
22266 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
22267 }
22268 {
22269 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
22270 }
22271 {
22272 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
22273 }
22274 {
22275 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
22276 }
22277 {
22278 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
22279 }
22280 {
22281 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
22282 }
22283 {
22284 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
22285 }
22286 {
22287 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
22288 }
22289 {
22290 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
22291 }
22292 {
22293 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
22294 }
22295 {
22296 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
22297 }
22298 {
22299 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
22300 }
22301 {
22302 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
22303 }
22304 {
22305 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
22306 }
22307 {
22308 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
22309 }
22310 {
22311 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
22312 }
22313 {
22314 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
22315 }
22316 {
22317 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
22318 }
22319 {
22320 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
22321 }
22322 {
22323 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
22324 }
22325 {
22326 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
22327 }
22328 {
22329 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
22330 }
22331 {
22332 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
22333 }
22334 {
22335 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
22336 }
22337 {
22338 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
22339 }
22340 {
22341 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
22342 }
22343 {
22344 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
22345 }
22346 {
22347 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
22348 }
22349 {
22350 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
22351 }
22352 {
22353 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
22354 }
22355 {
22356 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
22357 }
22358 {
22359 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
22360 }
22361 {
22362 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
22363 }
22364 {
22365 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
22366 }
22367 {
22368 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
22369 }
22370 {
22371 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
22372 }
22373 {
22374 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
22375 }
22376 {
22377 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
22378 }
22379 {
22380 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
22381 }
22382 {
22383 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
22384 }
22385 {
22386 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
22387 }
22388 {
22389 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
22390 }
22391 {
22392 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
22393 }
22394 {
22395 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
22396 }
22397 {
22398 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
22399 }
22400 {
22401 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
22402 }
22403 {
22404 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
22405 }
22406 {
22407 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
22408 }
22409 {
22410 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
22411 }
22412 {
22413 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
22414 }
22415 {
22416 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
22417 }
22418 {
22419 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
22420 }
22421 {
22422 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
22423 }
22424 {
22425 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
22426 }
22427 {
22428 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
22429 }
22430 {
22431 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
22432 }
22433 {
22434 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
22435 }
22436 {
22437 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
22438 }
22439 {
22440 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
22441 }
22442 {
22443 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
22444 }
22445 {
22446 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
22447 }
22448 {
22449 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
22450 }
22451 {
22452 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
22453 }
22454 {
22455 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
22456 }
22457 {
22458 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
22459 }
22460 {
22461 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
22462 }
22463 {
22464 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
22465 }
22466 {
22467 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
22468 }
22469 {
22470 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
22471 }
22472 {
22473 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
22474 }
22475 {
22476 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
22477 }
22478 {
22479 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
22480 }
22481 {
22482 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
22483 }
22484 {
22485 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
22486 }
22487 {
22488 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
22489 }
22490 {
22491 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
22492 }
22493 {
22494 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
22495 }
22496 {
22497 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
22498 }
22499 {
22500 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
22501 }
22502 {
22503 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
22504 }
22505 {
22506 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
22507 }
22508 {
22509 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
22510 }
22511 {
22512 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
22513 }
22514 {
22515 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
22516 }
22517 {
22518 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
22519 }
22520 {
22521 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
22522 }
22523 {
22524 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
22525 }
22526 {
22527 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
22528 }
22529 {
22530 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
22531 }
22532 {
22533 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
22534 }
22535 {
22536 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
22537 }
22538 {
22539 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
22540 }
22541 {
22542 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
22543 }
22544 {
22545 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
22546 }
22547 {
22548 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
22549 }
22550 {
22551 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
22552 }
22553 {
22554 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
22555 }
22556 {
22557 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
22558 }
22559 {
22560 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
22561 }
22562 {
22563 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
22564 }
22565 {
22566 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
22567 }
22568 {
22569 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
22570 }
22571 {
22572 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
22573 }
22574 {
22575 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
22576 }
22577 {
22578 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
22579 }
22580 {
22581 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
22582 }
22583 {
22584 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
22585 }
22586 {
22587 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
22588 }
22589 {
22590 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
22591 }
22592 {
22593 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
22594 }
22595 {
22596 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
22597 }
22598 {
22599 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
22600 }
22601
22602 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
22603
22604 {
22605 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
22606 }
22607 {
22608 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
22609 }
22610 {
22611 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
22612 }
22613 {
22614 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
22615 }
22616 {
22617 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
22618 }
22619 {
22620 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
22621 }
22622 {
22623 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
22624 }
22625 {
22626 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
22627 }
22628 {
22629 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
22630 }
22631 {
22632 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
22633 }
22634 {
22635 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
22636 }
22637 {
22638 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
22639 }
22640 {
22641 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
22642 }
22643 {
22644 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
22645 }
22646 {
22647 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
22648 }
22649 {
22650 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
22651 }
22652 {
22653 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
22654 }
22655 {
22656 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
22657 }
22658 {
22659 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
22660 }
22661 {
22662 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
22663 }
22664 {
22665 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
22666 }
22667 {
22668 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
22669 }
22670 {
22671 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
22672 }
22673 {
22674 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
22675 }
22676 {
22677 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
22678 }
22679 {
22680 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
22681 }
22682 {
22683 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
22684 }
22685 {
22686 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
22687 }
22688 {
22689 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
22690 }
22691 {
22692 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
22693 }
22694 {
22695 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
22696 }
22697 {
22698 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
22699 }
22700 {
22701 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
22702 }
22703 {
22704 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
22705 }
22706 {
22707 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
22708 }
22709 {
22710 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
22711 }
22712 {
22713 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
22714 }
22715 {
22716 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
22717 }
22718 {
22719 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
22720 }
22721 {
22722 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
22723 }
22724 {
22725 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
22726 }
22727 {
22728 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
22729 }
22730 {
22731 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
22732 }
22733 {
22734 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
22735 }
22736 {
22737 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
22738 }
22739 {
22740 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
22741 }
22742 {
22743 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
22744 }
22745 {
22746 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
22747 }
22748 {
22749 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
22750 }
22751 {
22752 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
22753 }
22754 {
22755 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
22756 }
22757 {
22758 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
22759 }
22760 {
22761 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
22762 }
22763 {
22764 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
22765 }
22766 {
22767 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
22768 }
22769 {
22770 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
22771 }
22772 {
22773 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
22774 }
22775 {
22776 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
22777 }
22778 {
22779 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
22780 }
22781 {
22782 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
22783 }
22784 {
22785 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
22786 }
22787 {
22788 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
22789 }
22790 {
22791 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
22792 }
22793 {
22794 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
22795 }
22796 {
22797 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
22798 }
22799 {
22800 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
22801 }
22802 {
22803 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
22804 }
22805 {
22806 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
22807 }
22808 {
22809 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
22810 }
22811 {
22812 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
22813 }
22814 {
22815 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
22816 }
22817 {
22818 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
22819 }
22820 {
22821 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
22822 }
22823 {
22824 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
22825 }
22826 {
22827 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
22828 }
22829 {
22830 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
22831 }
22832 {
22833 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
22834 }
22835 {
22836 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
22837 }
22838 {
22839 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
22840 }
22841 {
22842 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
22843 }
22844 {
22845 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
22846 }
22847 {
22848 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
22849 }
22850 {
22851 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
22852 }
22853 {
22854 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
22855 }
22856 {
22857 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
22858 }
22859 {
22860 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
22861 }
22862 {
22863 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
22864 }
22865 {
22866 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
22867 }
22868 {
22869 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
22870 }
22871 {
22872 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
22873 }
22874 {
22875 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
22876 }
22877 {
22878 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
22879 }
22880 {
22881 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
22882 }
22883 {
22884 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
22885 }
22886 {
22887 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
22888 }
22889 {
22890 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
22891 }
22892 {
22893 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
22894 }
22895 {
22896 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
22897 }
22898 {
22899 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
22900 }
22901 {
22902 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
22903 }
22904 {
22905 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
22906 }
22907 {
22908 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
22909 }
22910 {
22911 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
22912 }
22913 {
22914 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
22915 }
22916 {
22917 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
22918 }
22919 {
22920 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
22921 }
22922 {
22923 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
22924 }
22925 {
22926 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
22927 }
22928 {
22929 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
22930 }
22931 {
22932 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
22933 }
22934 {
22935 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
22936 }
22937 {
22938 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
22939 }
22940 {
22941 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
22942 }
22943 {
22944 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
22945 }
22946 {
22947 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
22948 }
22949 {
22950 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
22951 }
22952 {
22953 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
22954 }
22955 {
22956 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
22957 }
22958 {
22959 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
22960 }
22961 {
22962 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
22963 }
22964 {
22965 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
22966 }
22967 {
22968 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
22969 }
22970 {
22971 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
22972 }
22973 {
22974 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
22975 }
22976 {
22977 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
22978 }
22979 {
22980 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
22981 }
22982 {
22983 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
22984 }
22985 {
22986 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
22987 }
22988 {
22989 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
22990 }
22991 {
22992 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
22993 }
22994 {
22995 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
22996 }
22997 {
22998 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
22999 }
23000 {
23001 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
23002 }
23003 {
23004 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
23005 }
23006 {
23007 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
23008 }
23009 {
23010 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
23011 }
23012 {
23013 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
23014 }
23015 {
23016 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
23017 }
23018 {
23019 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
23020 }
23021 {
23022 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
23023 }
23024 {
23025 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
23026 }
23027 {
23028 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
23029 }
23030 {
23031 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
23032 }
23033 {
23034 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
23035 }
23036 {
23037 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
23038 }
23039 {
23040 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
23041 }
23042 {
23043 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
23044 }
23045 {
23046 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
23047 }
23048 {
23049 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
23050 }
23051 {
23052 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
23053 }
23054 {
23055 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
23056 }
23057 {
23058 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
23059 }
23060 {
23061 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
23062 }
23063 {
23064 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
23065 }
23066 {
23067 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
23068 }
23069 {
23070 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
23071 }
23072 {
23073 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
23074 }
23075 {
23076 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
23077 }
23078 {
23079 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
23080 }
23081 {
23082 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
23083 }
23084 {
23085 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
23086 }
23087 {
23088 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
23089 }
23090 {
23091 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
23092 }
23093 {
23094 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
23095 }
23096 {
23097 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
23098 }
23099 {
23100 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
23101 }
23102 {
23103 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
23104 }
23105 {
23106 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
23107 }
23108 {
23109 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
23110 }
23111 {
23112 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
23113 }
23114 {
23115 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
23116 }
23117 {
23118 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
23119 }
23120 {
23121 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
23122 }
23123 {
23124 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
23125 }
23126 {
23127 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
23128 }
23129 {
23130 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
23131 }
23132 {
23133 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
23134 }
23135 {
23136 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
23137 }
23138 {
23139 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
23140 }
23141 {
23142 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
23143 }
23144 {
23145 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
23146 }
23147 {
23148 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
23149 }
23150 {
23151 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
23152 }
23153 {
23154 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
23155 }
23156 {
23157 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
23158 }
23159 {
23160 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
23161 }
23162 {
23163 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
23164 }
23165 {
23166 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
23167 }
23168 {
23169 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
23170 }
23171 {
23172 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
23173 }
23174 {
23175 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
23176 }
23177 {
23178 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
23179 }
23180 {
23181 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
23182 }
23183 {
23184 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
23185 }
23186 {
23187 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
23188 }
23189 {
23190 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
23191 }
23192 {
23193 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
23194 }
23195 {
23196 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
23197 }
23198 {
23199 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
23200 }
23201 {
23202 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
23203 }
23204 {
23205 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
23206 }
23207 {
23208 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
23209 }
23210 {
23211 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
23212 }
23213 {
23214 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
23215 }
23216 {
23217 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
23218 }
23219 {
23220 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
23221 }
23222 {
23223 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
23224 }
23225 {
23226 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
23227 }
23228 {
23229 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
23230 }
23231 {
23232 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
23233 }
23234 {
23235 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
23236 }
23237 {
23238 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
23239 }
23240 {
23241 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
23242 }
23243 {
23244 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
23245 }
23246 {
23247 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
23248 }
23249 {
23250 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
23251 }
23252 {
23253 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
23254 }
23255 {
23256 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
23257 }
23258 {
23259 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
23260 }
23261 {
23262 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
23263 }
23264 {
23265 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
23266 }
23267 {
23268 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
23269 }
23270 {
23271 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
23272 }
23273 {
23274 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
23275 }
23276 {
23277 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
23278 }
23279 {
23280 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
23281 }
23282 {
23283 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
23284 }
23285 {
23286 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
23287 }
23288 {
23289 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
23290 }
23291 {
23292 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
23293 }
23294 {
23295 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
23296 }
23297 {
23298 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
23299 }
23300 {
23301 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
23302 }
23303 {
23304 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
23305 }
23306 {
23307 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
23308 }
23309 {
23310 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
23311 }
23312 {
23313 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
23314 }
23315 {
23316 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
23317 }
23318 {
23319 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
23320 }
23321 {
23322 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
23323 }
23324 {
23325 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
23326 }
23327 {
23328 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
23329 }
23330 {
23331 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
23332 }
23333 {
23334 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
23335 }
23336 {
23337 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
23338 }
23339 {
23340 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
23341 }
23342 {
23343 PyDict_SetItemString(d,"BUFFER_VIRTUAL_AREA", SWIG_From_int((int)(wxBUFFER_VIRTUAL_AREA)));
23344 }
23345 {
23346 PyDict_SetItemString(d,"BUFFER_CLIENT_AREA", SWIG_From_int((int)(wxBUFFER_CLIENT_AREA)));
23347 }
23348 {
23349 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
23350 }
23351 {
23352 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
23353 }
23354 {
23355 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
23356 }
23357 {
23358 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
23359 }
23360 {
23361 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
23362 }
23363 {
23364 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
23365 }
23366 {
23367 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
23368 }
23369 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
23370 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
23371 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
23372 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
23373 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
23374 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
23375 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
23376 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
23377 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
23378 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
23379 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
23380 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
23381 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
23382 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
23383 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
23384 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
23385 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
23386 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
23387 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
23388 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
23389 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
23390 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
23391 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
23392 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
23393 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
23394 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
23395 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
23396 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
23397 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
23398 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
23399 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
23400 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
23401 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
23402 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
23403 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
23404 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
23405 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
23406 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
23407 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
23408 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
23409 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
23410 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
23411 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
23412 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
23413 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
23414 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
23415 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
23416
23417 // Work around a chicken/egg problem in drawlist.cpp
23418 wxPyDrawList_SetAPIPtr();
23419
23420 }
23421
wxWidgets (Impactor)