]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_gdi_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
bug fixes for using wxTransientPopupWindow and wxDP_ALLOWNONE support from Andreas...
[wxWidgets.git] / wxPython / src / msw / _gdi_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxPostScriptDC swig_types[0]
1342 #define SWIGTYPE_p_wxBrush swig_types[1]
1343 #define SWIGTYPE_p_wxColour swig_types[2]
1344 #define SWIGTYPE_p_wxDC swig_types[3]
1345 #define SWIGTYPE_p_wxMirrorDC swig_types[4]
1346 #define SWIGTYPE_p_form_ops_t swig_types[5]
1347 #define SWIGTYPE_p_wxDuplexMode swig_types[6]
1348 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[7]
1349 #define SWIGTYPE_p_char swig_types[8]
1350 #define SWIGTYPE_p_wxIconLocation swig_types[9]
1351 #define SWIGTYPE_p_wxImage swig_types[10]
1352 #define SWIGTYPE_p_wxMetaFileDC swig_types[11]
1353 #define SWIGTYPE_p_wxMask swig_types[12]
1354 #define SWIGTYPE_p_wxSize swig_types[13]
1355 #define SWIGTYPE_p_wxFont swig_types[14]
1356 #define SWIGTYPE_p_wxWindow swig_types[15]
1357 #define SWIGTYPE_p_double swig_types[16]
1358 #define SWIGTYPE_p_wxMemoryDC swig_types[17]
1359 #define SWIGTYPE_p_wxFontMapper swig_types[18]
1360 #define SWIGTYPE_p_wxEffects swig_types[19]
1361 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[20]
1362 #define SWIGTYPE_p_wxPalette swig_types[21]
1363 #define SWIGTYPE_p_wxBitmap swig_types[22]
1364 #define SWIGTYPE_p_wxObject swig_types[23]
1365 #define SWIGTYPE_p_wxRegionIterator swig_types[24]
1366 #define SWIGTYPE_p_wxRect swig_types[25]
1367 #define SWIGTYPE_p_wxPaperSize swig_types[26]
1368 #define SWIGTYPE_p_wxString swig_types[27]
1369 #define SWIGTYPE_unsigned_int swig_types[28]
1370 #define SWIGTYPE_p_unsigned_int swig_types[29]
1371 #define SWIGTYPE_p_wxPrinterDC swig_types[30]
1372 #define SWIGTYPE_p_wxIconBundle swig_types[31]
1373 #define SWIGTYPE_p_wxPoint swig_types[32]
1374 #define SWIGTYPE_p_wxDash swig_types[33]
1375 #define SWIGTYPE_p_wxScreenDC swig_types[34]
1376 #define SWIGTYPE_p_wxCursor swig_types[35]
1377 #define SWIGTYPE_p_wxClientDC swig_types[36]
1378 #define SWIGTYPE_p_wxBufferedDC swig_types[37]
1379 #define SWIGTYPE_p_wxImageList swig_types[38]
1380 #define SWIGTYPE_p_unsigned_char swig_types[39]
1381 #define SWIGTYPE_p_wxGDIObject swig_types[40]
1382 #define SWIGTYPE_p_wxIcon swig_types[41]
1383 #define SWIGTYPE_p_wxLocale swig_types[42]
1384 #define SWIGTYPE_ptrdiff_t swig_types[43]
1385 #define SWIGTYPE_std__ptrdiff_t swig_types[44]
1386 #define SWIGTYPE_p_wxRegion swig_types[45]
1387 #define SWIGTYPE_p_wxConfigBase swig_types[46]
1388 #define SWIGTYPE_p_wxLanguageInfo swig_types[47]
1389 #define SWIGTYPE_p_wxWindowDC swig_types[48]
1390 #define SWIGTYPE_p_wxPrintData swig_types[49]
1391 #define SWIGTYPE_p_wxBrushList swig_types[50]
1392 #define SWIGTYPE_p_wxFontList swig_types[51]
1393 #define SWIGTYPE_p_wxPen swig_types[52]
1394 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[53]
1395 #define SWIGTYPE_p_wxPaintDC swig_types[54]
1396 #define SWIGTYPE_p_wxPenList swig_types[55]
1397 #define SWIGTYPE_p_int swig_types[56]
1398 #define SWIGTYPE_p_wxMetaFile swig_types[57]
1399 #define SWIGTYPE_p_unsigned_long swig_types[58]
1400 #define SWIGTYPE_p_wxNativeFontInfo swig_types[59]
1401 #define SWIGTYPE_p_wxEncodingConverter swig_types[60]
1402 #define SWIGTYPE_p_wxColourDatabase swig_types[61]
1403 static swig_type_info *swig_types[63];
1404
1405 /* -------- TYPES TABLE (END) -------- */
1406
1407
1408 /*-----------------------------------------------
1409 @(target):= _gdi_.so
1410 ------------------------------------------------*/
1411 #define SWIG_init init_gdi_
1412
1413 #define SWIG_name "_gdi_"
1414
1415 #include "wx/wxPython/wxPython.h"
1416 #include "wx/wxPython/pyclasses.h"
1417
1418
1419 static const wxString wxPyEmptyString(wxEmptyString);
1420
1421 #include <limits.h>
1422
1423
1424 SWIGINTERN int
1425 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1426 const char *errmsg)
1427 {
1428 if (value < min_value) {
1429 if (errmsg) {
1430 PyErr_Format(PyExc_OverflowError,
1431 "value %ld is less than '%s' minimum %ld",
1432 value, errmsg, min_value);
1433 }
1434 return 0;
1435 } else if (value > max_value) {
1436 if (errmsg) {
1437 PyErr_Format(PyExc_OverflowError,
1438 "value %ld is greater than '%s' maximum %ld",
1439 value, errmsg, max_value);
1440 }
1441 return 0;
1442 }
1443 return 1;
1444 }
1445
1446
1447 SWIGINTERN int
1448 SWIG_AsVal_long(PyObject* obj, long* val)
1449 {
1450 if (PyNumber_Check(obj)) {
1451 if (val) *val = PyInt_AsLong(obj);
1452 return 1;
1453 }
1454 else {
1455 SWIG_type_error("number", obj);
1456 }
1457 return 0;
1458 }
1459
1460
1461 #if INT_MAX != LONG_MAX
1462 SWIGINTERN int
1463 SWIG_AsVal_int(PyObject *obj, int *val)
1464 {
1465 const char* errmsg = val ? "int" : (char*)0;
1466 long v;
1467 if (SWIG_AsVal_long(obj, &v)) {
1468 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1469 if (val) *val = (int)(v);
1470 return 1;
1471 } else {
1472 return 0;
1473 }
1474 } else {
1475 PyErr_Clear();
1476 }
1477 if (val) {
1478 SWIG_type_error(errmsg, obj);
1479 }
1480 return 0;
1481 }
1482 #else
1483 SWIGINTERNSHORT int
1484 SWIG_AsVal_int(PyObject *obj, int *val)
1485 {
1486 return SWIG_AsVal_long(obj,(long*)val);
1487 }
1488 #endif
1489
1490
1491 SWIGINTERN int
1492 SWIG_AsVal_bool(PyObject *obj, bool *val)
1493 {
1494 if (obj == Py_True) {
1495 if (val) *val = true;
1496 return 1;
1497 }
1498 if (obj == Py_False) {
1499 if (val) *val = false;
1500 return 1;
1501 }
1502 int res = 0;
1503 if (SWIG_AsVal_int(obj, &res)) {
1504 if (val) *val = res ? true : false;
1505 return 1;
1506 } else {
1507 PyErr_Clear();
1508 }
1509 if (val) {
1510 SWIG_type_error("bool", obj);
1511 }
1512 return 0;
1513 }
1514
1515
1516 SWIGINTERNSHORT bool
1517 SWIG_As_bool(PyObject* obj)
1518 {
1519 bool v;
1520 if (!SWIG_AsVal_bool(obj, &v)) {
1521 /*
1522 this is needed to make valgrind/purify happier.
1523 */
1524 memset((void*)&v, 0, sizeof(bool));
1525 }
1526 return v;
1527 }
1528
1529
1530 SWIGINTERNSHORT int
1531 SWIG_Check_bool(PyObject* obj)
1532 {
1533 return SWIG_AsVal_bool(obj, (bool*)0);
1534 }
1535
1536
1537 SWIGINTERN int
1538 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1539 {
1540 long v = 0;
1541 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1542 SWIG_type_error("unsigned number", obj);
1543 }
1544 else if (val)
1545 *val = (unsigned long)v;
1546 return 1;
1547 }
1548
1549
1550 SWIGINTERNSHORT int
1551 SWIG_CheckUnsignedLongInRange(unsigned long value,
1552 unsigned long max_value,
1553 const char *errmsg)
1554 {
1555 if (value > max_value) {
1556 if (errmsg) {
1557 PyErr_Format(PyExc_OverflowError,
1558 "value %lu is greater than '%s' minimum %lu",
1559 value, errmsg, max_value);
1560 }
1561 return 0;
1562 }
1563 return 1;
1564 }
1565
1566
1567 SWIGINTERN int
1568 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1569 {
1570 const char* errmsg = val ? "unsigned char" : (char*)0;
1571 unsigned long v;
1572 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1573 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1574 if (val) *val = (unsigned char)(v);
1575 return 1;
1576 } else {
1577 return 0;
1578 }
1579 } else {
1580 PyErr_Clear();
1581 }
1582 if (val) {
1583 SWIG_type_error(errmsg, obj);
1584 }
1585 return 0;
1586 }
1587
1588
1589 SWIGINTERNSHORT unsigned char
1590 SWIG_As_unsigned_SS_char(PyObject* obj)
1591 {
1592 unsigned char v;
1593 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1594 /*
1595 this is needed to make valgrind/purify happier.
1596 */
1597 memset((void*)&v, 0, sizeof(unsigned char));
1598 }
1599 return v;
1600 }
1601
1602
1603 SWIGINTERNSHORT int
1604 SWIG_Check_unsigned_SS_char(PyObject* obj)
1605 {
1606 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1607 }
1608
1609
1610 SWIGINTERNSHORT unsigned long
1611 SWIG_As_unsigned_SS_long(PyObject* obj)
1612 {
1613 unsigned long v;
1614 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1615 /*
1616 this is needed to make valgrind/purify happier.
1617 */
1618 memset((void*)&v, 0, sizeof(unsigned long));
1619 }
1620 return v;
1621 }
1622
1623
1624 SWIGINTERNSHORT int
1625 SWIG_Check_unsigned_SS_long(PyObject* obj)
1626 {
1627 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1628 }
1629
1630
1631 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1632 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1633 /*@@*/
1634
1635
1636 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1637 #define SWIG_From_long PyInt_FromLong
1638 /*@@*/
1639
1640 static PyObject *wxColour_Get(wxColour *self){
1641 PyObject* rv = PyTuple_New(3);
1642 int red = -1;
1643 int green = -1;
1644 int blue = -1;
1645 if (self->Ok()) {
1646 red = self->Red();
1647 green = self->Green();
1648 blue = self->Blue();
1649 }
1650 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1651 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1652 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1653 return rv;
1654 }
1655 static unsigned long wxColour_GetRGB(wxColour *self){
1656 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1657 }
1658
1659 SWIGINTERNSHORT PyObject*
1660 SWIG_From_unsigned_SS_long(unsigned long value)
1661 {
1662 return (value > LONG_MAX) ?
1663 PyLong_FromUnsignedLong(value)
1664 : PyInt_FromLong((long)(value));
1665 }
1666
1667
1668 SWIGINTERNSHORT int
1669 SWIG_As_int(PyObject* obj)
1670 {
1671 int v;
1672 if (!SWIG_AsVal_int(obj, &v)) {
1673 /*
1674 this is needed to make valgrind/purify happier.
1675 */
1676 memset((void*)&v, 0, sizeof(int));
1677 }
1678 return v;
1679 }
1680
1681
1682 SWIGINTERNSHORT int
1683 SWIG_Check_int(PyObject* obj)
1684 {
1685 return SWIG_AsVal_int(obj, (int*)0);
1686 }
1687
1688
1689 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1690 #define SWIG_From_int PyInt_FromLong
1691 /*@@*/
1692
1693
1694 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1695 PyObject* o2;
1696 PyObject* o3;
1697
1698 if (!target) {
1699 target = o;
1700 } else if (target == Py_None) {
1701 Py_DECREF(Py_None);
1702 target = o;
1703 } else {
1704 if (!PyTuple_Check(target)) {
1705 o2 = target;
1706 target = PyTuple_New(1);
1707 PyTuple_SetItem(target, 0, o2);
1708 }
1709 o3 = PyTuple_New(1);
1710 PyTuple_SetItem(o3, 0, o);
1711
1712 o2 = target;
1713 target = PySequence_Concat(o2, o3);
1714 Py_DECREF(o2);
1715 Py_DECREF(o3);
1716 }
1717 return target;
1718 }
1719
1720
1721 static PyObject *wxPen_GetDashes(wxPen *self){
1722 wxDash* dashes;
1723 int count = self->GetDashes(&dashes);
1724 bool blocked = wxPyBeginBlockThreads();
1725 PyObject* retval = PyList_New(0);
1726 for (int x=0; x<count; x++) {
1727 PyObject* pyint = PyInt_FromLong(dashes[x]);
1728 PyList_Append(retval, pyint);
1729 Py_DECREF(pyint);
1730 }
1731 wxPyEndBlockThreads(blocked);
1732 return retval;
1733 }
1734 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1735 bool blocked = wxPyBeginBlockThreads();
1736 int size = PyList_Size(pyDashes);
1737 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1738
1739 // black magic warning! The array of wxDashes needs to exist as
1740 // long as the pen does because wxPen does not copy the array. So
1741 // stick a copy in a Python string object and attach it to _self,
1742 // and then call SetDashes with a pointer to that array. Then
1743 // when the Python pen object is destroyed the array will be
1744 // cleaned up too.
1745 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1746 PyObject_SetAttrString(_self, "_dashes", strDashes);
1747
1748 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1749 delete [] dashes;
1750 Py_DECREF(strDashes);
1751 wxPyEndBlockThreads(blocked);
1752 }
1753 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1754 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1755
1756 #include <wx/image.h>
1757
1758 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1759 char** cArray = NULL;
1760 int count;
1761
1762 if (!PyList_Check(listOfStrings)) {
1763 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1764 return NULL;
1765 }
1766 count = PyList_Size(listOfStrings);
1767 cArray = new char*[count];
1768
1769 for(int x=0; x<count; x++) {
1770 // TODO: Need some validation and error checking here
1771 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1772 }
1773 return cArray;
1774 }
1775
1776
1777 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1778 char** cArray = NULL;
1779 wxBitmap* bmp;
1780
1781 cArray = ConvertListOfStrings(listOfStrings);
1782 if (! cArray)
1783 return NULL;
1784 bmp = new wxBitmap(cArray);
1785 delete [] cArray;
1786 return bmp;
1787 }
1788 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1789 char* buf;
1790 int length;
1791 PyString_AsStringAndSize(bits, &buf, &length);
1792 return new wxBitmap(buf, width, height, depth);
1793 }
1794
1795 SWIGINTERNSHORT long
1796 SWIG_As_long(PyObject* obj)
1797 {
1798 long v;
1799 if (!SWIG_AsVal_long(obj, &v)) {
1800 /*
1801 this is needed to make valgrind/purify happier.
1802 */
1803 memset((void*)&v, 0, sizeof(long));
1804 }
1805 return v;
1806 }
1807
1808
1809 SWIGINTERNSHORT int
1810 SWIG_Check_long(PyObject* obj)
1811 {
1812 return SWIG_AsVal_long(obj, (long*)0);
1813 }
1814
1815 static void wxBitmap_SetHandle(wxBitmap *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1816 static wxSize wxBitmap_GetSize(wxBitmap *self){
1817 wxSize size(self->GetWidth(), self->GetHeight());
1818 return size;
1819 }
1820 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1821 wxMask *mask = new wxMask(*self, colour);
1822 self->SetMask(mask);
1823 }
1824 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1825 self->SetWidth(size.x);
1826 self->SetHeight(size.y);
1827 }
1828 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1829 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1830 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1831 if ( !colour.Ok() )
1832 return new wxMask(bitmap, *wxBLACK);
1833 else
1834 return new wxMask(bitmap, colour);
1835 }
1836
1837 #include <wx/iconbndl.h>
1838
1839 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1840 wxIcon* icon = new wxIcon();
1841 icon->CopyFromBitmap(bmp);
1842 return icon;
1843 }
1844 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1845 char** cArray = NULL;
1846 wxIcon* icon;
1847
1848 cArray = ConvertListOfStrings(listOfStrings);
1849 if (! cArray)
1850 return NULL;
1851 icon = new wxIcon(cArray);
1852 delete [] cArray;
1853 return icon;
1854 }
1855 static void wxIcon_SetHandle(wxIcon *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1856 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1857
1858 return new wxIconLocation(*filename, num);
1859
1860
1861
1862 }
1863 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1864
1865 self->SetIndex(num);
1866
1867
1868
1869 }
1870 static int wxIconLocation_GetIndex(wxIconLocation *self){
1871
1872 return self->GetIndex();
1873
1874
1875
1876 }
1877 static wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1878 #ifdef __WXGTK__
1879 wxImage img(cursorName, type);
1880 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
1881 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
1882 return new wxCursor(img);
1883 #else
1884 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
1885 #endif
1886 }
1887 static void wxCursor_SetHandle(wxCursor *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1888
1889
1890 static void wxRegionIterator_Next(wxRegionIterator *self){
1891 (*self) ++;
1892 }
1893 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1894 return self->operator bool();
1895 }
1896
1897 #include <wx/fontutil.h>
1898 #include <wx/fontmap.h>
1899 #include <wx/fontenum.h>
1900
1901 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1902 return self->ToString();
1903 }
1904
1905 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding)
1906 { wxPyRaiseNotImplemented(); return NULL; }
1907
1908 bool wxTestFontEncoding(const wxNativeEncodingInfo& info)
1909 { wxPyRaiseNotImplemented(); return false; }
1910
1911 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1912 wxFontEncoding alt_enc;
1913 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1914 return PyInt_FromLong(alt_enc);
1915 else {
1916 Py_INCREF(Py_None);
1917 return Py_None;
1918 }
1919 }
1920 static wxFont *new_wxFont(wxString const &info){
1921 wxNativeFontInfo nfi;
1922 nfi.FromString(info);
1923 return new wxFont(nfi);
1924 }
1925 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1926 return wxFont::New(pointSize, family, flags, face, encoding);
1927 }
1928 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1929 return wxFontBase::New(pixelSize, family,
1930 style, weight, underlined,
1931 face, encoding);
1932 }
1933 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1934 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1935
1936 class wxPyFontEnumerator : public wxFontEnumerator {
1937 public:
1938 wxPyFontEnumerator() {}
1939 ~wxPyFontEnumerator() {}
1940
1941 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1942 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1943
1944 PYPRIVATE;
1945 };
1946
1947 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
1948 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
1949
1950
1951 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
1952 wxArrayString* arr = self->GetEncodings();
1953 if (arr)
1954 return wxArrayString2PyList_helper(*arr);
1955 else
1956 return PyList_New(0);
1957 }
1958 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
1959 wxArrayString* arr = self->GetFacenames();
1960 if (arr)
1961 return wxArrayString2PyList_helper(*arr);
1962 else
1963 return PyList_New(0);
1964 }
1965
1966 #include <locale.h>
1967
1968 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1969 wxLocale* loc;
1970 if (language == -1)
1971 loc = new wxLocale();
1972 else
1973 loc = new wxLocale(language, flags);
1974 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1975 // for the floating point conversions and such to work right.
1976 #if PY_VERSION_HEX < 0x02040000
1977 setlocale(LC_NUMERIC, "C");
1978 #endif
1979 return loc;
1980 }
1981 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
1982 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
1983 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1984 // for the floating point conversions and such to work right.
1985 #if PY_VERSION_HEX < 0x02040000
1986 setlocale(LC_NUMERIC, "C");
1987 #endif
1988 return rc;
1989 }
1990 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1991 bool rc = self->Init(language, flags);
1992 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1993 // for the floating point conversions and such to work right.
1994 #if PY_VERSION_HEX < 0x02040000
1995 setlocale(LC_NUMERIC, "C");
1996 #endif
1997 return rc;
1998 }
1999
2000 #include "wx/wxPython/pydrawxxx.h"
2001
2002 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2003 wxColour col;
2004 self->GetPixel(x, y, &col);
2005 return col;
2006 }
2007 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2008 wxColour col;
2009 self->GetPixel(pt, &col);
2010 return col;
2011 }
2012
2013 SWIGINTERN int
2014 SWIG_AsVal_double(PyObject *obj, double* val)
2015 {
2016 if (PyNumber_Check(obj)) {
2017 if (val) *val = PyFloat_AsDouble(obj);
2018 return 1;
2019 }
2020 else {
2021 SWIG_type_error("number", obj);
2022 }
2023 return 0;
2024 }
2025
2026
2027 SWIGINTERNSHORT double
2028 SWIG_As_double(PyObject* obj)
2029 {
2030 double v;
2031 if (!SWIG_AsVal_double(obj, &v)) {
2032 /*
2033 this is needed to make valgrind/purify happier.
2034 */
2035 memset((void*)&v, 0, sizeof(double));
2036 }
2037 return v;
2038 }
2039
2040
2041 SWIGINTERNSHORT int
2042 SWIG_Check_double(PyObject* obj)
2043 {
2044 return SWIG_AsVal_double(obj, (double*)0);
2045 }
2046
2047 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2048 wxRect rv;
2049 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2050 return rv;
2051 }
2052
2053 static wxRect wxDC_GetClippingRect(wxDC *self){
2054 wxRect rect;
2055 self->GetClippingBox(rect);
2056 return rect;
2057 }
2058 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2059 wxArrayInt widths;
2060 self->GetPartialTextExtents(text, widths);
2061 return widths;
2062 }
2063
2064 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2065 #define SWIG_From_double PyFloat_FromDouble
2066 /*@@*/
2067
2068
2069 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2070 self->SetLogicalOrigin(point.x, point.y);
2071 }
2072 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2073 self->SetDeviceOrigin(point.x, point.y);
2074 }
2075 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2076 self->CalcBoundingBox(point.x, point.y);
2077 }
2078 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2079 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2080 }
2081 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2082 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2083 }
2084 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2085 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2086 }
2087 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2088 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2089 }
2090 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2091 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2092 }
2093 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2094 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2095 }
2096
2097 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2098 *x1 = dc->MinX();
2099 *y1 = dc->MinY();
2100 *x2 = dc->MaxX();
2101 *y2 = dc->MaxY();
2102 }
2103
2104
2105 #include <wx/dcbuffer.h>
2106
2107
2108 #include <wx/dcps.h>
2109
2110
2111 #include <wx/metafile.h>
2112
2113
2114
2115 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2116 self->AddColour(name, wxColour(red, green, blue));
2117 }
2118
2119 #include <wx/effects.h>
2120
2121 #ifdef __cplusplus
2122 extern "C" {
2123 #endif
2124 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2125 PyObject *resultobj;
2126 wxGDIObject *result;
2127 char *kwnames[] = {
2128 NULL
2129 };
2130
2131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2132 {
2133 if (!wxPyCheckForApp()) SWIG_fail;
2134 PyThreadState* __tstate = wxPyBeginAllowThreads();
2135 result = (wxGDIObject *)new wxGDIObject();
2136
2137 wxPyEndAllowThreads(__tstate);
2138 if (PyErr_Occurred()) SWIG_fail;
2139 }
2140 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2141 return resultobj;
2142 fail:
2143 return NULL;
2144 }
2145
2146
2147 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2148 PyObject *resultobj;
2149 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2150 PyObject * obj0 = 0 ;
2151 char *kwnames[] = {
2152 (char *) "self", NULL
2153 };
2154
2155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2157 if (SWIG_arg_fail(1)) SWIG_fail;
2158 {
2159 PyThreadState* __tstate = wxPyBeginAllowThreads();
2160 delete arg1;
2161
2162 wxPyEndAllowThreads(__tstate);
2163 if (PyErr_Occurred()) SWIG_fail;
2164 }
2165 Py_INCREF(Py_None); resultobj = Py_None;
2166 return resultobj;
2167 fail:
2168 return NULL;
2169 }
2170
2171
2172 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2173 PyObject *resultobj;
2174 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2175 bool result;
2176 PyObject * obj0 = 0 ;
2177 char *kwnames[] = {
2178 (char *) "self", NULL
2179 };
2180
2181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2183 if (SWIG_arg_fail(1)) SWIG_fail;
2184 {
2185 PyThreadState* __tstate = wxPyBeginAllowThreads();
2186 result = (bool)(arg1)->GetVisible();
2187
2188 wxPyEndAllowThreads(__tstate);
2189 if (PyErr_Occurred()) SWIG_fail;
2190 }
2191 {
2192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2193 }
2194 return resultobj;
2195 fail:
2196 return NULL;
2197 }
2198
2199
2200 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2201 PyObject *resultobj;
2202 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2203 bool arg2 ;
2204 PyObject * obj0 = 0 ;
2205 PyObject * obj1 = 0 ;
2206 char *kwnames[] = {
2207 (char *) "self",(char *) "visible", NULL
2208 };
2209
2210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2212 if (SWIG_arg_fail(1)) SWIG_fail;
2213 {
2214 arg2 = (bool)(SWIG_As_bool(obj1));
2215 if (SWIG_arg_fail(2)) SWIG_fail;
2216 }
2217 {
2218 PyThreadState* __tstate = wxPyBeginAllowThreads();
2219 (arg1)->SetVisible(arg2);
2220
2221 wxPyEndAllowThreads(__tstate);
2222 if (PyErr_Occurred()) SWIG_fail;
2223 }
2224 Py_INCREF(Py_None); resultobj = Py_None;
2225 return resultobj;
2226 fail:
2227 return NULL;
2228 }
2229
2230
2231 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2232 PyObject *resultobj;
2233 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2234 bool result;
2235 PyObject * obj0 = 0 ;
2236 char *kwnames[] = {
2237 (char *) "self", NULL
2238 };
2239
2240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2242 if (SWIG_arg_fail(1)) SWIG_fail;
2243 {
2244 PyThreadState* __tstate = wxPyBeginAllowThreads();
2245 result = (bool)(arg1)->IsNull();
2246
2247 wxPyEndAllowThreads(__tstate);
2248 if (PyErr_Occurred()) SWIG_fail;
2249 }
2250 {
2251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2252 }
2253 return resultobj;
2254 fail:
2255 return NULL;
2256 }
2257
2258
2259 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2260 PyObject *obj;
2261 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2262 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2263 Py_INCREF(obj);
2264 return Py_BuildValue((char *)"");
2265 }
2266 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2267 PyObject *resultobj;
2268 byte arg1 = (byte) 0 ;
2269 byte arg2 = (byte) 0 ;
2270 byte arg3 = (byte) 0 ;
2271 wxColour *result;
2272 PyObject * obj0 = 0 ;
2273 PyObject * obj1 = 0 ;
2274 PyObject * obj2 = 0 ;
2275 char *kwnames[] = {
2276 (char *) "red",(char *) "green",(char *) "blue", NULL
2277 };
2278
2279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2280 if (obj0) {
2281 {
2282 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2283 if (SWIG_arg_fail(1)) SWIG_fail;
2284 }
2285 }
2286 if (obj1) {
2287 {
2288 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2289 if (SWIG_arg_fail(2)) SWIG_fail;
2290 }
2291 }
2292 if (obj2) {
2293 {
2294 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2295 if (SWIG_arg_fail(3)) SWIG_fail;
2296 }
2297 }
2298 {
2299 PyThreadState* __tstate = wxPyBeginAllowThreads();
2300 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2301
2302 wxPyEndAllowThreads(__tstate);
2303 if (PyErr_Occurred()) SWIG_fail;
2304 }
2305 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2306 return resultobj;
2307 fail:
2308 return NULL;
2309 }
2310
2311
2312 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2313 PyObject *resultobj;
2314 wxString *arg1 = 0 ;
2315 wxColour *result;
2316 bool temp1 = false ;
2317 PyObject * obj0 = 0 ;
2318 char *kwnames[] = {
2319 (char *) "colorName", NULL
2320 };
2321
2322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2323 {
2324 arg1 = wxString_in_helper(obj0);
2325 if (arg1 == NULL) SWIG_fail;
2326 temp1 = true;
2327 }
2328 {
2329 if (!wxPyCheckForApp()) SWIG_fail;
2330 PyThreadState* __tstate = wxPyBeginAllowThreads();
2331 result = (wxColour *)new wxColour((wxString const &)*arg1);
2332
2333 wxPyEndAllowThreads(__tstate);
2334 if (PyErr_Occurred()) SWIG_fail;
2335 }
2336 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2337 {
2338 if (temp1)
2339 delete arg1;
2340 }
2341 return resultobj;
2342 fail:
2343 {
2344 if (temp1)
2345 delete arg1;
2346 }
2347 return NULL;
2348 }
2349
2350
2351 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2352 PyObject *resultobj;
2353 unsigned long arg1 ;
2354 wxColour *result;
2355 PyObject * obj0 = 0 ;
2356 char *kwnames[] = {
2357 (char *) "colRGB", NULL
2358 };
2359
2360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2361 {
2362 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2363 if (SWIG_arg_fail(1)) SWIG_fail;
2364 }
2365 {
2366 PyThreadState* __tstate = wxPyBeginAllowThreads();
2367 result = (wxColour *)new wxColour(arg1);
2368
2369 wxPyEndAllowThreads(__tstate);
2370 if (PyErr_Occurred()) SWIG_fail;
2371 }
2372 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2373 return resultobj;
2374 fail:
2375 return NULL;
2376 }
2377
2378
2379 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2380 PyObject *resultobj;
2381 wxColour *arg1 = (wxColour *) 0 ;
2382 PyObject * obj0 = 0 ;
2383 char *kwnames[] = {
2384 (char *) "self", NULL
2385 };
2386
2387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2389 if (SWIG_arg_fail(1)) SWIG_fail;
2390 {
2391 PyThreadState* __tstate = wxPyBeginAllowThreads();
2392 delete arg1;
2393
2394 wxPyEndAllowThreads(__tstate);
2395 if (PyErr_Occurred()) SWIG_fail;
2396 }
2397 Py_INCREF(Py_None); resultobj = Py_None;
2398 return resultobj;
2399 fail:
2400 return NULL;
2401 }
2402
2403
2404 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2405 PyObject *resultobj;
2406 wxColour *arg1 = (wxColour *) 0 ;
2407 byte result;
2408 PyObject * obj0 = 0 ;
2409 char *kwnames[] = {
2410 (char *) "self", NULL
2411 };
2412
2413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2415 if (SWIG_arg_fail(1)) SWIG_fail;
2416 {
2417 PyThreadState* __tstate = wxPyBeginAllowThreads();
2418 result = (byte)(arg1)->Red();
2419
2420 wxPyEndAllowThreads(__tstate);
2421 if (PyErr_Occurred()) SWIG_fail;
2422 }
2423 {
2424 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2425 }
2426 return resultobj;
2427 fail:
2428 return NULL;
2429 }
2430
2431
2432 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2433 PyObject *resultobj;
2434 wxColour *arg1 = (wxColour *) 0 ;
2435 byte result;
2436 PyObject * obj0 = 0 ;
2437 char *kwnames[] = {
2438 (char *) "self", NULL
2439 };
2440
2441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2443 if (SWIG_arg_fail(1)) SWIG_fail;
2444 {
2445 PyThreadState* __tstate = wxPyBeginAllowThreads();
2446 result = (byte)(arg1)->Green();
2447
2448 wxPyEndAllowThreads(__tstate);
2449 if (PyErr_Occurred()) SWIG_fail;
2450 }
2451 {
2452 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2453 }
2454 return resultobj;
2455 fail:
2456 return NULL;
2457 }
2458
2459
2460 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2461 PyObject *resultobj;
2462 wxColour *arg1 = (wxColour *) 0 ;
2463 byte result;
2464 PyObject * obj0 = 0 ;
2465 char *kwnames[] = {
2466 (char *) "self", NULL
2467 };
2468
2469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2471 if (SWIG_arg_fail(1)) SWIG_fail;
2472 {
2473 PyThreadState* __tstate = wxPyBeginAllowThreads();
2474 result = (byte)(arg1)->Blue();
2475
2476 wxPyEndAllowThreads(__tstate);
2477 if (PyErr_Occurred()) SWIG_fail;
2478 }
2479 {
2480 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2481 }
2482 return resultobj;
2483 fail:
2484 return NULL;
2485 }
2486
2487
2488 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2489 PyObject *resultobj;
2490 wxColour *arg1 = (wxColour *) 0 ;
2491 bool result;
2492 PyObject * obj0 = 0 ;
2493 char *kwnames[] = {
2494 (char *) "self", NULL
2495 };
2496
2497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2499 if (SWIG_arg_fail(1)) SWIG_fail;
2500 {
2501 PyThreadState* __tstate = wxPyBeginAllowThreads();
2502 result = (bool)(arg1)->Ok();
2503
2504 wxPyEndAllowThreads(__tstate);
2505 if (PyErr_Occurred()) SWIG_fail;
2506 }
2507 {
2508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2509 }
2510 return resultobj;
2511 fail:
2512 return NULL;
2513 }
2514
2515
2516 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2517 PyObject *resultobj;
2518 wxColour *arg1 = (wxColour *) 0 ;
2519 byte arg2 ;
2520 byte arg3 ;
2521 byte arg4 ;
2522 PyObject * obj0 = 0 ;
2523 PyObject * obj1 = 0 ;
2524 PyObject * obj2 = 0 ;
2525 PyObject * obj3 = 0 ;
2526 char *kwnames[] = {
2527 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2528 };
2529
2530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2532 if (SWIG_arg_fail(1)) SWIG_fail;
2533 {
2534 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2535 if (SWIG_arg_fail(2)) SWIG_fail;
2536 }
2537 {
2538 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2539 if (SWIG_arg_fail(3)) SWIG_fail;
2540 }
2541 {
2542 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2543 if (SWIG_arg_fail(4)) SWIG_fail;
2544 }
2545 {
2546 PyThreadState* __tstate = wxPyBeginAllowThreads();
2547 (arg1)->Set(arg2,arg3,arg4);
2548
2549 wxPyEndAllowThreads(__tstate);
2550 if (PyErr_Occurred()) SWIG_fail;
2551 }
2552 Py_INCREF(Py_None); resultobj = Py_None;
2553 return resultobj;
2554 fail:
2555 return NULL;
2556 }
2557
2558
2559 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2560 PyObject *resultobj;
2561 wxColour *arg1 = (wxColour *) 0 ;
2562 unsigned long arg2 ;
2563 PyObject * obj0 = 0 ;
2564 PyObject * obj1 = 0 ;
2565 char *kwnames[] = {
2566 (char *) "self",(char *) "colRGB", NULL
2567 };
2568
2569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2571 if (SWIG_arg_fail(1)) SWIG_fail;
2572 {
2573 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2574 if (SWIG_arg_fail(2)) SWIG_fail;
2575 }
2576 {
2577 PyThreadState* __tstate = wxPyBeginAllowThreads();
2578 (arg1)->Set(arg2);
2579
2580 wxPyEndAllowThreads(__tstate);
2581 if (PyErr_Occurred()) SWIG_fail;
2582 }
2583 Py_INCREF(Py_None); resultobj = Py_None;
2584 return resultobj;
2585 fail:
2586 return NULL;
2587 }
2588
2589
2590 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2591 PyObject *resultobj;
2592 wxColour *arg1 = (wxColour *) 0 ;
2593 wxString *arg2 = 0 ;
2594 bool temp2 = false ;
2595 PyObject * obj0 = 0 ;
2596 PyObject * obj1 = 0 ;
2597 char *kwnames[] = {
2598 (char *) "self",(char *) "colourName", NULL
2599 };
2600
2601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2603 if (SWIG_arg_fail(1)) SWIG_fail;
2604 {
2605 arg2 = wxString_in_helper(obj1);
2606 if (arg2 == NULL) SWIG_fail;
2607 temp2 = true;
2608 }
2609 {
2610 PyThreadState* __tstate = wxPyBeginAllowThreads();
2611 (arg1)->InitFromName((wxString const &)*arg2);
2612
2613 wxPyEndAllowThreads(__tstate);
2614 if (PyErr_Occurred()) SWIG_fail;
2615 }
2616 Py_INCREF(Py_None); resultobj = Py_None;
2617 {
2618 if (temp2)
2619 delete arg2;
2620 }
2621 return resultobj;
2622 fail:
2623 {
2624 if (temp2)
2625 delete arg2;
2626 }
2627 return NULL;
2628 }
2629
2630
2631 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2632 PyObject *resultobj;
2633 wxColour *arg1 = (wxColour *) 0 ;
2634 long result;
2635 PyObject * obj0 = 0 ;
2636 char *kwnames[] = {
2637 (char *) "self", NULL
2638 };
2639
2640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2642 if (SWIG_arg_fail(1)) SWIG_fail;
2643 {
2644 PyThreadState* __tstate = wxPyBeginAllowThreads();
2645 result = (long)((wxColour const *)arg1)->GetPixel();
2646
2647 wxPyEndAllowThreads(__tstate);
2648 if (PyErr_Occurred()) SWIG_fail;
2649 }
2650 {
2651 resultobj = SWIG_From_long((long)(result));
2652 }
2653 return resultobj;
2654 fail:
2655 return NULL;
2656 }
2657
2658
2659 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2660 PyObject *resultobj;
2661 wxColour *arg1 = (wxColour *) 0 ;
2662 wxColour *arg2 = 0 ;
2663 bool result;
2664 wxColour temp2 ;
2665 PyObject * obj0 = 0 ;
2666 PyObject * obj1 = 0 ;
2667 char *kwnames[] = {
2668 (char *) "self",(char *) "colour", NULL
2669 };
2670
2671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2673 if (SWIG_arg_fail(1)) SWIG_fail;
2674 {
2675 arg2 = &temp2;
2676 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2677 }
2678 {
2679 PyThreadState* __tstate = wxPyBeginAllowThreads();
2680 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2681
2682 wxPyEndAllowThreads(__tstate);
2683 if (PyErr_Occurred()) SWIG_fail;
2684 }
2685 {
2686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2687 }
2688 return resultobj;
2689 fail:
2690 return NULL;
2691 }
2692
2693
2694 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2695 PyObject *resultobj;
2696 wxColour *arg1 = (wxColour *) 0 ;
2697 wxColour *arg2 = 0 ;
2698 bool result;
2699 wxColour temp2 ;
2700 PyObject * obj0 = 0 ;
2701 PyObject * obj1 = 0 ;
2702 char *kwnames[] = {
2703 (char *) "self",(char *) "colour", NULL
2704 };
2705
2706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2708 if (SWIG_arg_fail(1)) SWIG_fail;
2709 {
2710 arg2 = &temp2;
2711 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2712 }
2713 {
2714 PyThreadState* __tstate = wxPyBeginAllowThreads();
2715 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2716
2717 wxPyEndAllowThreads(__tstate);
2718 if (PyErr_Occurred()) SWIG_fail;
2719 }
2720 {
2721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2722 }
2723 return resultobj;
2724 fail:
2725 return NULL;
2726 }
2727
2728
2729 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2730 PyObject *resultobj;
2731 wxColour *arg1 = (wxColour *) 0 ;
2732 PyObject *result;
2733 PyObject * obj0 = 0 ;
2734 char *kwnames[] = {
2735 (char *) "self", NULL
2736 };
2737
2738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2740 if (SWIG_arg_fail(1)) SWIG_fail;
2741 {
2742 PyThreadState* __tstate = wxPyBeginAllowThreads();
2743 result = (PyObject *)wxColour_Get(arg1);
2744
2745 wxPyEndAllowThreads(__tstate);
2746 if (PyErr_Occurred()) SWIG_fail;
2747 }
2748 resultobj = result;
2749 return resultobj;
2750 fail:
2751 return NULL;
2752 }
2753
2754
2755 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2756 PyObject *resultobj;
2757 wxColour *arg1 = (wxColour *) 0 ;
2758 unsigned long result;
2759 PyObject * obj0 = 0 ;
2760 char *kwnames[] = {
2761 (char *) "self", NULL
2762 };
2763
2764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2766 if (SWIG_arg_fail(1)) SWIG_fail;
2767 {
2768 PyThreadState* __tstate = wxPyBeginAllowThreads();
2769 result = (unsigned long)wxColour_GetRGB(arg1);
2770
2771 wxPyEndAllowThreads(__tstate);
2772 if (PyErr_Occurred()) SWIG_fail;
2773 }
2774 {
2775 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2776 }
2777 return resultobj;
2778 fail:
2779 return NULL;
2780 }
2781
2782
2783 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2784 PyObject *obj;
2785 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2786 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2787 Py_INCREF(obj);
2788 return Py_BuildValue((char *)"");
2789 }
2790 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2791 PyObject *resultobj;
2792 int arg1 ;
2793 unsigned char *arg2 = (unsigned char *) 0 ;
2794 unsigned char *arg3 = (unsigned char *) 0 ;
2795 unsigned char *arg4 = (unsigned char *) 0 ;
2796 wxPalette *result;
2797 PyObject * obj0 = 0 ;
2798 PyObject * obj1 = 0 ;
2799 PyObject * obj2 = 0 ;
2800 PyObject * obj3 = 0 ;
2801 char *kwnames[] = {
2802 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2803 };
2804
2805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2806 {
2807 arg1 = (int)(SWIG_As_int(obj0));
2808 if (SWIG_arg_fail(1)) SWIG_fail;
2809 }
2810 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2811 if (SWIG_arg_fail(2)) SWIG_fail;
2812 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2813 if (SWIG_arg_fail(3)) SWIG_fail;
2814 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2815 if (SWIG_arg_fail(4)) SWIG_fail;
2816 {
2817 if (!wxPyCheckForApp()) SWIG_fail;
2818 PyThreadState* __tstate = wxPyBeginAllowThreads();
2819 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2820
2821 wxPyEndAllowThreads(__tstate);
2822 if (PyErr_Occurred()) SWIG_fail;
2823 }
2824 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2825 return resultobj;
2826 fail:
2827 return NULL;
2828 }
2829
2830
2831 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2832 PyObject *resultobj;
2833 wxPalette *arg1 = (wxPalette *) 0 ;
2834 PyObject * obj0 = 0 ;
2835 char *kwnames[] = {
2836 (char *) "self", NULL
2837 };
2838
2839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2841 if (SWIG_arg_fail(1)) SWIG_fail;
2842 {
2843 PyThreadState* __tstate = wxPyBeginAllowThreads();
2844 delete arg1;
2845
2846 wxPyEndAllowThreads(__tstate);
2847 if (PyErr_Occurred()) SWIG_fail;
2848 }
2849 Py_INCREF(Py_None); resultobj = Py_None;
2850 return resultobj;
2851 fail:
2852 return NULL;
2853 }
2854
2855
2856 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2857 PyObject *resultobj;
2858 wxPalette *arg1 = (wxPalette *) 0 ;
2859 byte arg2 ;
2860 byte arg3 ;
2861 byte arg4 ;
2862 int result;
2863 PyObject * obj0 = 0 ;
2864 PyObject * obj1 = 0 ;
2865 PyObject * obj2 = 0 ;
2866 PyObject * obj3 = 0 ;
2867 char *kwnames[] = {
2868 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2869 };
2870
2871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2873 if (SWIG_arg_fail(1)) SWIG_fail;
2874 {
2875 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2876 if (SWIG_arg_fail(2)) SWIG_fail;
2877 }
2878 {
2879 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2880 if (SWIG_arg_fail(3)) SWIG_fail;
2881 }
2882 {
2883 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2884 if (SWIG_arg_fail(4)) SWIG_fail;
2885 }
2886 {
2887 PyThreadState* __tstate = wxPyBeginAllowThreads();
2888 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2889
2890 wxPyEndAllowThreads(__tstate);
2891 if (PyErr_Occurred()) SWIG_fail;
2892 }
2893 {
2894 resultobj = SWIG_From_int((int)(result));
2895 }
2896 return resultobj;
2897 fail:
2898 return NULL;
2899 }
2900
2901
2902 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2903 PyObject *resultobj;
2904 wxPalette *arg1 = (wxPalette *) 0 ;
2905 int arg2 ;
2906 byte *arg3 = (byte *) 0 ;
2907 byte *arg4 = (byte *) 0 ;
2908 byte *arg5 = (byte *) 0 ;
2909 bool result;
2910 byte temp3 ;
2911 int res3 = 0 ;
2912 byte temp4 ;
2913 int res4 = 0 ;
2914 byte temp5 ;
2915 int res5 = 0 ;
2916 PyObject * obj0 = 0 ;
2917 PyObject * obj1 = 0 ;
2918 char *kwnames[] = {
2919 (char *) "self",(char *) "pixel", NULL
2920 };
2921
2922 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2923 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2924 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2927 if (SWIG_arg_fail(1)) SWIG_fail;
2928 {
2929 arg2 = (int)(SWIG_As_int(obj1));
2930 if (SWIG_arg_fail(2)) SWIG_fail;
2931 }
2932 {
2933 PyThreadState* __tstate = wxPyBeginAllowThreads();
2934 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2935
2936 wxPyEndAllowThreads(__tstate);
2937 if (PyErr_Occurred()) SWIG_fail;
2938 }
2939 {
2940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2941 }
2942 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2943 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2944 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2945 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2946 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2947 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2948 return resultobj;
2949 fail:
2950 return NULL;
2951 }
2952
2953
2954 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
2955 PyObject *resultobj;
2956 wxPalette *arg1 = (wxPalette *) 0 ;
2957 int result;
2958 PyObject * obj0 = 0 ;
2959 char *kwnames[] = {
2960 (char *) "self", NULL
2961 };
2962
2963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
2964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2965 if (SWIG_arg_fail(1)) SWIG_fail;
2966 {
2967 PyThreadState* __tstate = wxPyBeginAllowThreads();
2968 result = (int)((wxPalette const *)arg1)->GetColoursCount();
2969
2970 wxPyEndAllowThreads(__tstate);
2971 if (PyErr_Occurred()) SWIG_fail;
2972 }
2973 {
2974 resultobj = SWIG_From_int((int)(result));
2975 }
2976 return resultobj;
2977 fail:
2978 return NULL;
2979 }
2980
2981
2982 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2983 PyObject *resultobj;
2984 wxPalette *arg1 = (wxPalette *) 0 ;
2985 bool result;
2986 PyObject * obj0 = 0 ;
2987 char *kwnames[] = {
2988 (char *) "self", NULL
2989 };
2990
2991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
2992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2993 if (SWIG_arg_fail(1)) SWIG_fail;
2994 {
2995 PyThreadState* __tstate = wxPyBeginAllowThreads();
2996 result = (bool)(arg1)->Ok();
2997
2998 wxPyEndAllowThreads(__tstate);
2999 if (PyErr_Occurred()) SWIG_fail;
3000 }
3001 {
3002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3003 }
3004 return resultobj;
3005 fail:
3006 return NULL;
3007 }
3008
3009
3010 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3011 PyObject *obj;
3012 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3013 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3014 Py_INCREF(obj);
3015 return Py_BuildValue((char *)"");
3016 }
3017 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3018 PyObject *resultobj;
3019 wxColour *arg1 = 0 ;
3020 int arg2 = (int) 1 ;
3021 int arg3 = (int) wxSOLID ;
3022 wxPen *result;
3023 wxColour temp1 ;
3024 PyObject * obj0 = 0 ;
3025 PyObject * obj1 = 0 ;
3026 PyObject * obj2 = 0 ;
3027 char *kwnames[] = {
3028 (char *) "colour",(char *) "width",(char *) "style", NULL
3029 };
3030
3031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3032 {
3033 arg1 = &temp1;
3034 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3035 }
3036 if (obj1) {
3037 {
3038 arg2 = (int)(SWIG_As_int(obj1));
3039 if (SWIG_arg_fail(2)) SWIG_fail;
3040 }
3041 }
3042 if (obj2) {
3043 {
3044 arg3 = (int)(SWIG_As_int(obj2));
3045 if (SWIG_arg_fail(3)) SWIG_fail;
3046 }
3047 }
3048 {
3049 if (!wxPyCheckForApp()) SWIG_fail;
3050 PyThreadState* __tstate = wxPyBeginAllowThreads();
3051 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3052
3053 wxPyEndAllowThreads(__tstate);
3054 if (PyErr_Occurred()) SWIG_fail;
3055 }
3056 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3057 return resultobj;
3058 fail:
3059 return NULL;
3060 }
3061
3062
3063 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3064 PyObject *resultobj;
3065 wxPen *arg1 = (wxPen *) 0 ;
3066 PyObject * obj0 = 0 ;
3067 char *kwnames[] = {
3068 (char *) "self", NULL
3069 };
3070
3071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3073 if (SWIG_arg_fail(1)) SWIG_fail;
3074 {
3075 PyThreadState* __tstate = wxPyBeginAllowThreads();
3076 delete arg1;
3077
3078 wxPyEndAllowThreads(__tstate);
3079 if (PyErr_Occurred()) SWIG_fail;
3080 }
3081 Py_INCREF(Py_None); resultobj = Py_None;
3082 return resultobj;
3083 fail:
3084 return NULL;
3085 }
3086
3087
3088 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3089 PyObject *resultobj;
3090 wxPen *arg1 = (wxPen *) 0 ;
3091 int result;
3092 PyObject * obj0 = 0 ;
3093 char *kwnames[] = {
3094 (char *) "self", NULL
3095 };
3096
3097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3099 if (SWIG_arg_fail(1)) SWIG_fail;
3100 {
3101 PyThreadState* __tstate = wxPyBeginAllowThreads();
3102 result = (int)(arg1)->GetCap();
3103
3104 wxPyEndAllowThreads(__tstate);
3105 if (PyErr_Occurred()) SWIG_fail;
3106 }
3107 {
3108 resultobj = SWIG_From_int((int)(result));
3109 }
3110 return resultobj;
3111 fail:
3112 return NULL;
3113 }
3114
3115
3116 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3117 PyObject *resultobj;
3118 wxPen *arg1 = (wxPen *) 0 ;
3119 wxColour result;
3120 PyObject * obj0 = 0 ;
3121 char *kwnames[] = {
3122 (char *) "self", NULL
3123 };
3124
3125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3127 if (SWIG_arg_fail(1)) SWIG_fail;
3128 {
3129 PyThreadState* __tstate = wxPyBeginAllowThreads();
3130 result = (arg1)->GetColour();
3131
3132 wxPyEndAllowThreads(__tstate);
3133 if (PyErr_Occurred()) SWIG_fail;
3134 }
3135 {
3136 wxColour * resultptr;
3137 resultptr = new wxColour((wxColour &)(result));
3138 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3139 }
3140 return resultobj;
3141 fail:
3142 return NULL;
3143 }
3144
3145
3146 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3147 PyObject *resultobj;
3148 wxPen *arg1 = (wxPen *) 0 ;
3149 int result;
3150 PyObject * obj0 = 0 ;
3151 char *kwnames[] = {
3152 (char *) "self", NULL
3153 };
3154
3155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3157 if (SWIG_arg_fail(1)) SWIG_fail;
3158 {
3159 PyThreadState* __tstate = wxPyBeginAllowThreads();
3160 result = (int)(arg1)->GetJoin();
3161
3162 wxPyEndAllowThreads(__tstate);
3163 if (PyErr_Occurred()) SWIG_fail;
3164 }
3165 {
3166 resultobj = SWIG_From_int((int)(result));
3167 }
3168 return resultobj;
3169 fail:
3170 return NULL;
3171 }
3172
3173
3174 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3175 PyObject *resultobj;
3176 wxPen *arg1 = (wxPen *) 0 ;
3177 int result;
3178 PyObject * obj0 = 0 ;
3179 char *kwnames[] = {
3180 (char *) "self", NULL
3181 };
3182
3183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3185 if (SWIG_arg_fail(1)) SWIG_fail;
3186 {
3187 PyThreadState* __tstate = wxPyBeginAllowThreads();
3188 result = (int)(arg1)->GetStyle();
3189
3190 wxPyEndAllowThreads(__tstate);
3191 if (PyErr_Occurred()) SWIG_fail;
3192 }
3193 {
3194 resultobj = SWIG_From_int((int)(result));
3195 }
3196 return resultobj;
3197 fail:
3198 return NULL;
3199 }
3200
3201
3202 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3203 PyObject *resultobj;
3204 wxPen *arg1 = (wxPen *) 0 ;
3205 int result;
3206 PyObject * obj0 = 0 ;
3207 char *kwnames[] = {
3208 (char *) "self", NULL
3209 };
3210
3211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3213 if (SWIG_arg_fail(1)) SWIG_fail;
3214 {
3215 PyThreadState* __tstate = wxPyBeginAllowThreads();
3216 result = (int)(arg1)->GetWidth();
3217
3218 wxPyEndAllowThreads(__tstate);
3219 if (PyErr_Occurred()) SWIG_fail;
3220 }
3221 {
3222 resultobj = SWIG_From_int((int)(result));
3223 }
3224 return resultobj;
3225 fail:
3226 return NULL;
3227 }
3228
3229
3230 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3231 PyObject *resultobj;
3232 wxPen *arg1 = (wxPen *) 0 ;
3233 bool result;
3234 PyObject * obj0 = 0 ;
3235 char *kwnames[] = {
3236 (char *) "self", NULL
3237 };
3238
3239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3241 if (SWIG_arg_fail(1)) SWIG_fail;
3242 {
3243 PyThreadState* __tstate = wxPyBeginAllowThreads();
3244 result = (bool)(arg1)->Ok();
3245
3246 wxPyEndAllowThreads(__tstate);
3247 if (PyErr_Occurred()) SWIG_fail;
3248 }
3249 {
3250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3251 }
3252 return resultobj;
3253 fail:
3254 return NULL;
3255 }
3256
3257
3258 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3259 PyObject *resultobj;
3260 wxPen *arg1 = (wxPen *) 0 ;
3261 int arg2 ;
3262 PyObject * obj0 = 0 ;
3263 PyObject * obj1 = 0 ;
3264 char *kwnames[] = {
3265 (char *) "self",(char *) "cap_style", NULL
3266 };
3267
3268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3270 if (SWIG_arg_fail(1)) SWIG_fail;
3271 {
3272 arg2 = (int)(SWIG_As_int(obj1));
3273 if (SWIG_arg_fail(2)) SWIG_fail;
3274 }
3275 {
3276 PyThreadState* __tstate = wxPyBeginAllowThreads();
3277 (arg1)->SetCap(arg2);
3278
3279 wxPyEndAllowThreads(__tstate);
3280 if (PyErr_Occurred()) SWIG_fail;
3281 }
3282 Py_INCREF(Py_None); resultobj = Py_None;
3283 return resultobj;
3284 fail:
3285 return NULL;
3286 }
3287
3288
3289 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3290 PyObject *resultobj;
3291 wxPen *arg1 = (wxPen *) 0 ;
3292 wxColour *arg2 = 0 ;
3293 wxColour temp2 ;
3294 PyObject * obj0 = 0 ;
3295 PyObject * obj1 = 0 ;
3296 char *kwnames[] = {
3297 (char *) "self",(char *) "colour", NULL
3298 };
3299
3300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3302 if (SWIG_arg_fail(1)) SWIG_fail;
3303 {
3304 arg2 = &temp2;
3305 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3306 }
3307 {
3308 PyThreadState* __tstate = wxPyBeginAllowThreads();
3309 (arg1)->SetColour(*arg2);
3310
3311 wxPyEndAllowThreads(__tstate);
3312 if (PyErr_Occurred()) SWIG_fail;
3313 }
3314 Py_INCREF(Py_None); resultobj = Py_None;
3315 return resultobj;
3316 fail:
3317 return NULL;
3318 }
3319
3320
3321 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3322 PyObject *resultobj;
3323 wxPen *arg1 = (wxPen *) 0 ;
3324 int arg2 ;
3325 PyObject * obj0 = 0 ;
3326 PyObject * obj1 = 0 ;
3327 char *kwnames[] = {
3328 (char *) "self",(char *) "join_style", NULL
3329 };
3330
3331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3333 if (SWIG_arg_fail(1)) SWIG_fail;
3334 {
3335 arg2 = (int)(SWIG_As_int(obj1));
3336 if (SWIG_arg_fail(2)) SWIG_fail;
3337 }
3338 {
3339 PyThreadState* __tstate = wxPyBeginAllowThreads();
3340 (arg1)->SetJoin(arg2);
3341
3342 wxPyEndAllowThreads(__tstate);
3343 if (PyErr_Occurred()) SWIG_fail;
3344 }
3345 Py_INCREF(Py_None); resultobj = Py_None;
3346 return resultobj;
3347 fail:
3348 return NULL;
3349 }
3350
3351
3352 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3353 PyObject *resultobj;
3354 wxPen *arg1 = (wxPen *) 0 ;
3355 int arg2 ;
3356 PyObject * obj0 = 0 ;
3357 PyObject * obj1 = 0 ;
3358 char *kwnames[] = {
3359 (char *) "self",(char *) "style", NULL
3360 };
3361
3362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3364 if (SWIG_arg_fail(1)) SWIG_fail;
3365 {
3366 arg2 = (int)(SWIG_As_int(obj1));
3367 if (SWIG_arg_fail(2)) SWIG_fail;
3368 }
3369 {
3370 PyThreadState* __tstate = wxPyBeginAllowThreads();
3371 (arg1)->SetStyle(arg2);
3372
3373 wxPyEndAllowThreads(__tstate);
3374 if (PyErr_Occurred()) SWIG_fail;
3375 }
3376 Py_INCREF(Py_None); resultobj = Py_None;
3377 return resultobj;
3378 fail:
3379 return NULL;
3380 }
3381
3382
3383 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3384 PyObject *resultobj;
3385 wxPen *arg1 = (wxPen *) 0 ;
3386 int arg2 ;
3387 PyObject * obj0 = 0 ;
3388 PyObject * obj1 = 0 ;
3389 char *kwnames[] = {
3390 (char *) "self",(char *) "width", NULL
3391 };
3392
3393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3395 if (SWIG_arg_fail(1)) SWIG_fail;
3396 {
3397 arg2 = (int)(SWIG_As_int(obj1));
3398 if (SWIG_arg_fail(2)) SWIG_fail;
3399 }
3400 {
3401 PyThreadState* __tstate = wxPyBeginAllowThreads();
3402 (arg1)->SetWidth(arg2);
3403
3404 wxPyEndAllowThreads(__tstate);
3405 if (PyErr_Occurred()) SWIG_fail;
3406 }
3407 Py_INCREF(Py_None); resultobj = Py_None;
3408 return resultobj;
3409 fail:
3410 return NULL;
3411 }
3412
3413
3414 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3415 PyObject *resultobj;
3416 wxPen *arg1 = (wxPen *) 0 ;
3417 int arg2 ;
3418 wxDash *arg3 = (wxDash *) 0 ;
3419 PyObject * obj0 = 0 ;
3420 PyObject * obj1 = 0 ;
3421 char *kwnames[] = {
3422 (char *) "self",(char *) "dashes", NULL
3423 };
3424
3425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3427 if (SWIG_arg_fail(1)) SWIG_fail;
3428 {
3429 arg2 = PyList_Size(obj1);
3430 arg3 = (wxDash*)byte_LIST_helper(obj1);
3431 if (arg3 == NULL) SWIG_fail;
3432 }
3433 {
3434 PyThreadState* __tstate = wxPyBeginAllowThreads();
3435 (arg1)->SetDashes(arg2,arg3);
3436
3437 wxPyEndAllowThreads(__tstate);
3438 if (PyErr_Occurred()) SWIG_fail;
3439 }
3440 Py_INCREF(Py_None); resultobj = Py_None;
3441 {
3442 if (arg3) delete [] arg3;
3443 }
3444 return resultobj;
3445 fail:
3446 {
3447 if (arg3) delete [] arg3;
3448 }
3449 return NULL;
3450 }
3451
3452
3453 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3454 PyObject *resultobj;
3455 wxPen *arg1 = (wxPen *) 0 ;
3456 PyObject *result;
3457 PyObject * obj0 = 0 ;
3458 char *kwnames[] = {
3459 (char *) "self", NULL
3460 };
3461
3462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3464 if (SWIG_arg_fail(1)) SWIG_fail;
3465 {
3466 PyThreadState* __tstate = wxPyBeginAllowThreads();
3467 result = (PyObject *)wxPen_GetDashes(arg1);
3468
3469 wxPyEndAllowThreads(__tstate);
3470 if (PyErr_Occurred()) SWIG_fail;
3471 }
3472 resultobj = result;
3473 return resultobj;
3474 fail:
3475 return NULL;
3476 }
3477
3478
3479 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3480 PyObject *resultobj;
3481 wxPen *arg1 = (wxPen *) 0 ;
3482 PyObject *arg2 = (PyObject *) 0 ;
3483 PyObject *arg3 = (PyObject *) 0 ;
3484 PyObject * obj0 = 0 ;
3485 PyObject * obj1 = 0 ;
3486 PyObject * obj2 = 0 ;
3487 char *kwnames[] = {
3488 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3489 };
3490
3491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3493 if (SWIG_arg_fail(1)) SWIG_fail;
3494 arg2 = obj1;
3495 arg3 = obj2;
3496 {
3497 PyThreadState* __tstate = wxPyBeginAllowThreads();
3498 wxPen__SetDashes(arg1,arg2,arg3);
3499
3500 wxPyEndAllowThreads(__tstate);
3501 if (PyErr_Occurred()) SWIG_fail;
3502 }
3503 Py_INCREF(Py_None); resultobj = Py_None;
3504 return resultobj;
3505 fail:
3506 return NULL;
3507 }
3508
3509
3510 static PyObject *_wrap_Pen_GetDashCount(PyObject *, PyObject *args, PyObject *kwargs) {
3511 PyObject *resultobj;
3512 wxPen *arg1 = (wxPen *) 0 ;
3513 int result;
3514 PyObject * obj0 = 0 ;
3515 char *kwnames[] = {
3516 (char *) "self", NULL
3517 };
3518
3519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashCount",kwnames,&obj0)) goto fail;
3520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3521 if (SWIG_arg_fail(1)) SWIG_fail;
3522 {
3523 PyThreadState* __tstate = wxPyBeginAllowThreads();
3524 result = (int)((wxPen const *)arg1)->GetDashCount();
3525
3526 wxPyEndAllowThreads(__tstate);
3527 if (PyErr_Occurred()) SWIG_fail;
3528 }
3529 {
3530 resultobj = SWIG_From_int((int)(result));
3531 }
3532 return resultobj;
3533 fail:
3534 return NULL;
3535 }
3536
3537
3538 static PyObject *_wrap_Pen_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3539 PyObject *resultobj;
3540 wxPen *arg1 = (wxPen *) 0 ;
3541 wxBitmap *result;
3542 PyObject * obj0 = 0 ;
3543 char *kwnames[] = {
3544 (char *) "self", NULL
3545 };
3546
3547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStipple",kwnames,&obj0)) goto fail;
3548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3549 if (SWIG_arg_fail(1)) SWIG_fail;
3550 {
3551 PyThreadState* __tstate = wxPyBeginAllowThreads();
3552 result = (wxBitmap *)(arg1)->GetStipple();
3553
3554 wxPyEndAllowThreads(__tstate);
3555 if (PyErr_Occurred()) SWIG_fail;
3556 }
3557 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3558 return resultobj;
3559 fail:
3560 return NULL;
3561 }
3562
3563
3564 static PyObject *_wrap_Pen_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3565 PyObject *resultobj;
3566 wxPen *arg1 = (wxPen *) 0 ;
3567 wxBitmap *arg2 = 0 ;
3568 PyObject * obj0 = 0 ;
3569 PyObject * obj1 = 0 ;
3570 char *kwnames[] = {
3571 (char *) "self",(char *) "stipple", NULL
3572 };
3573
3574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3576 if (SWIG_arg_fail(1)) SWIG_fail;
3577 {
3578 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3579 if (SWIG_arg_fail(2)) SWIG_fail;
3580 if (arg2 == NULL) {
3581 SWIG_null_ref("wxBitmap");
3582 }
3583 if (SWIG_arg_fail(2)) SWIG_fail;
3584 }
3585 {
3586 PyThreadState* __tstate = wxPyBeginAllowThreads();
3587 (arg1)->SetStipple(*arg2);
3588
3589 wxPyEndAllowThreads(__tstate);
3590 if (PyErr_Occurred()) SWIG_fail;
3591 }
3592 Py_INCREF(Py_None); resultobj = Py_None;
3593 return resultobj;
3594 fail:
3595 return NULL;
3596 }
3597
3598
3599 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3600 PyObject *resultobj;
3601 wxPen *arg1 = (wxPen *) 0 ;
3602 wxPen *arg2 = (wxPen *) 0 ;
3603 bool result;
3604 PyObject * obj0 = 0 ;
3605 PyObject * obj1 = 0 ;
3606 char *kwnames[] = {
3607 (char *) "self",(char *) "other", NULL
3608 };
3609
3610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3612 if (SWIG_arg_fail(1)) SWIG_fail;
3613 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3614 if (SWIG_arg_fail(2)) SWIG_fail;
3615 {
3616 PyThreadState* __tstate = wxPyBeginAllowThreads();
3617 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3618
3619 wxPyEndAllowThreads(__tstate);
3620 if (PyErr_Occurred()) SWIG_fail;
3621 }
3622 {
3623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3624 }
3625 return resultobj;
3626 fail:
3627 return NULL;
3628 }
3629
3630
3631 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3632 PyObject *resultobj;
3633 wxPen *arg1 = (wxPen *) 0 ;
3634 wxPen *arg2 = (wxPen *) 0 ;
3635 bool result;
3636 PyObject * obj0 = 0 ;
3637 PyObject * obj1 = 0 ;
3638 char *kwnames[] = {
3639 (char *) "self",(char *) "other", NULL
3640 };
3641
3642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3644 if (SWIG_arg_fail(1)) SWIG_fail;
3645 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3646 if (SWIG_arg_fail(2)) SWIG_fail;
3647 {
3648 PyThreadState* __tstate = wxPyBeginAllowThreads();
3649 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3650
3651 wxPyEndAllowThreads(__tstate);
3652 if (PyErr_Occurred()) SWIG_fail;
3653 }
3654 {
3655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3656 }
3657 return resultobj;
3658 fail:
3659 return NULL;
3660 }
3661
3662
3663 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3664 PyObject *obj;
3665 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3666 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3667 Py_INCREF(obj);
3668 return Py_BuildValue((char *)"");
3669 }
3670 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3671 PyObject *resultobj;
3672 wxColour *arg1 = 0 ;
3673 int arg2 = (int) wxSOLID ;
3674 wxBrush *result;
3675 wxColour temp1 ;
3676 PyObject * obj0 = 0 ;
3677 PyObject * obj1 = 0 ;
3678 char *kwnames[] = {
3679 (char *) "colour",(char *) "style", NULL
3680 };
3681
3682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3683 {
3684 arg1 = &temp1;
3685 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3686 }
3687 if (obj1) {
3688 {
3689 arg2 = (int)(SWIG_As_int(obj1));
3690 if (SWIG_arg_fail(2)) SWIG_fail;
3691 }
3692 }
3693 {
3694 if (!wxPyCheckForApp()) SWIG_fail;
3695 PyThreadState* __tstate = wxPyBeginAllowThreads();
3696 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3697
3698 wxPyEndAllowThreads(__tstate);
3699 if (PyErr_Occurred()) SWIG_fail;
3700 }
3701 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3702 return resultobj;
3703 fail:
3704 return NULL;
3705 }
3706
3707
3708 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3709 PyObject *resultobj;
3710 wxBrush *arg1 = (wxBrush *) 0 ;
3711 PyObject * obj0 = 0 ;
3712 char *kwnames[] = {
3713 (char *) "self", NULL
3714 };
3715
3716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3718 if (SWIG_arg_fail(1)) SWIG_fail;
3719 {
3720 PyThreadState* __tstate = wxPyBeginAllowThreads();
3721 delete arg1;
3722
3723 wxPyEndAllowThreads(__tstate);
3724 if (PyErr_Occurred()) SWIG_fail;
3725 }
3726 Py_INCREF(Py_None); resultobj = Py_None;
3727 return resultobj;
3728 fail:
3729 return NULL;
3730 }
3731
3732
3733 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3734 PyObject *resultobj;
3735 wxBrush *arg1 = (wxBrush *) 0 ;
3736 wxColour *arg2 = 0 ;
3737 wxColour temp2 ;
3738 PyObject * obj0 = 0 ;
3739 PyObject * obj1 = 0 ;
3740 char *kwnames[] = {
3741 (char *) "self",(char *) "col", NULL
3742 };
3743
3744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3746 if (SWIG_arg_fail(1)) SWIG_fail;
3747 {
3748 arg2 = &temp2;
3749 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3750 }
3751 {
3752 PyThreadState* __tstate = wxPyBeginAllowThreads();
3753 (arg1)->SetColour((wxColour const &)*arg2);
3754
3755 wxPyEndAllowThreads(__tstate);
3756 if (PyErr_Occurred()) SWIG_fail;
3757 }
3758 Py_INCREF(Py_None); resultobj = Py_None;
3759 return resultobj;
3760 fail:
3761 return NULL;
3762 }
3763
3764
3765 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3766 PyObject *resultobj;
3767 wxBrush *arg1 = (wxBrush *) 0 ;
3768 int arg2 ;
3769 PyObject * obj0 = 0 ;
3770 PyObject * obj1 = 0 ;
3771 char *kwnames[] = {
3772 (char *) "self",(char *) "style", NULL
3773 };
3774
3775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3777 if (SWIG_arg_fail(1)) SWIG_fail;
3778 {
3779 arg2 = (int)(SWIG_As_int(obj1));
3780 if (SWIG_arg_fail(2)) SWIG_fail;
3781 }
3782 {
3783 PyThreadState* __tstate = wxPyBeginAllowThreads();
3784 (arg1)->SetStyle(arg2);
3785
3786 wxPyEndAllowThreads(__tstate);
3787 if (PyErr_Occurred()) SWIG_fail;
3788 }
3789 Py_INCREF(Py_None); resultobj = Py_None;
3790 return resultobj;
3791 fail:
3792 return NULL;
3793 }
3794
3795
3796 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3797 PyObject *resultobj;
3798 wxBrush *arg1 = (wxBrush *) 0 ;
3799 wxBitmap *arg2 = 0 ;
3800 PyObject * obj0 = 0 ;
3801 PyObject * obj1 = 0 ;
3802 char *kwnames[] = {
3803 (char *) "self",(char *) "stipple", NULL
3804 };
3805
3806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3808 if (SWIG_arg_fail(1)) SWIG_fail;
3809 {
3810 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3811 if (SWIG_arg_fail(2)) SWIG_fail;
3812 if (arg2 == NULL) {
3813 SWIG_null_ref("wxBitmap");
3814 }
3815 if (SWIG_arg_fail(2)) SWIG_fail;
3816 }
3817 {
3818 PyThreadState* __tstate = wxPyBeginAllowThreads();
3819 (arg1)->SetStipple((wxBitmap const &)*arg2);
3820
3821 wxPyEndAllowThreads(__tstate);
3822 if (PyErr_Occurred()) SWIG_fail;
3823 }
3824 Py_INCREF(Py_None); resultobj = Py_None;
3825 return resultobj;
3826 fail:
3827 return NULL;
3828 }
3829
3830
3831 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3832 PyObject *resultobj;
3833 wxBrush *arg1 = (wxBrush *) 0 ;
3834 wxColour result;
3835 PyObject * obj0 = 0 ;
3836 char *kwnames[] = {
3837 (char *) "self", NULL
3838 };
3839
3840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3842 if (SWIG_arg_fail(1)) SWIG_fail;
3843 {
3844 PyThreadState* __tstate = wxPyBeginAllowThreads();
3845 result = ((wxBrush const *)arg1)->GetColour();
3846
3847 wxPyEndAllowThreads(__tstate);
3848 if (PyErr_Occurred()) SWIG_fail;
3849 }
3850 {
3851 wxColour * resultptr;
3852 resultptr = new wxColour((wxColour &)(result));
3853 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3854 }
3855 return resultobj;
3856 fail:
3857 return NULL;
3858 }
3859
3860
3861 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3862 PyObject *resultobj;
3863 wxBrush *arg1 = (wxBrush *) 0 ;
3864 int result;
3865 PyObject * obj0 = 0 ;
3866 char *kwnames[] = {
3867 (char *) "self", NULL
3868 };
3869
3870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3872 if (SWIG_arg_fail(1)) SWIG_fail;
3873 {
3874 PyThreadState* __tstate = wxPyBeginAllowThreads();
3875 result = (int)((wxBrush const *)arg1)->GetStyle();
3876
3877 wxPyEndAllowThreads(__tstate);
3878 if (PyErr_Occurred()) SWIG_fail;
3879 }
3880 {
3881 resultobj = SWIG_From_int((int)(result));
3882 }
3883 return resultobj;
3884 fail:
3885 return NULL;
3886 }
3887
3888
3889 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3890 PyObject *resultobj;
3891 wxBrush *arg1 = (wxBrush *) 0 ;
3892 wxBitmap *result;
3893 PyObject * obj0 = 0 ;
3894 char *kwnames[] = {
3895 (char *) "self", NULL
3896 };
3897
3898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3900 if (SWIG_arg_fail(1)) SWIG_fail;
3901 {
3902 PyThreadState* __tstate = wxPyBeginAllowThreads();
3903 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3904
3905 wxPyEndAllowThreads(__tstate);
3906 if (PyErr_Occurred()) SWIG_fail;
3907 }
3908 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3909 return resultobj;
3910 fail:
3911 return NULL;
3912 }
3913
3914
3915 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3916 PyObject *resultobj;
3917 wxBrush *arg1 = (wxBrush *) 0 ;
3918 bool result;
3919 PyObject * obj0 = 0 ;
3920 char *kwnames[] = {
3921 (char *) "self", NULL
3922 };
3923
3924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3926 if (SWIG_arg_fail(1)) SWIG_fail;
3927 {
3928 PyThreadState* __tstate = wxPyBeginAllowThreads();
3929 result = (bool)((wxBrush const *)arg1)->IsHatch();
3930
3931 wxPyEndAllowThreads(__tstate);
3932 if (PyErr_Occurred()) SWIG_fail;
3933 }
3934 {
3935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3936 }
3937 return resultobj;
3938 fail:
3939 return NULL;
3940 }
3941
3942
3943 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3944 PyObject *resultobj;
3945 wxBrush *arg1 = (wxBrush *) 0 ;
3946 bool result;
3947 PyObject * obj0 = 0 ;
3948 char *kwnames[] = {
3949 (char *) "self", NULL
3950 };
3951
3952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3954 if (SWIG_arg_fail(1)) SWIG_fail;
3955 {
3956 PyThreadState* __tstate = wxPyBeginAllowThreads();
3957 result = (bool)(arg1)->Ok();
3958
3959 wxPyEndAllowThreads(__tstate);
3960 if (PyErr_Occurred()) SWIG_fail;
3961 }
3962 {
3963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3964 }
3965 return resultobj;
3966 fail:
3967 return NULL;
3968 }
3969
3970
3971 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
3972 PyObject *obj;
3973 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3974 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
3975 Py_INCREF(obj);
3976 return Py_BuildValue((char *)"");
3977 }
3978 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3979 PyObject *resultobj;
3980 wxString *arg1 = 0 ;
3981 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
3982 wxBitmap *result;
3983 bool temp1 = false ;
3984 PyObject * obj0 = 0 ;
3985 PyObject * obj1 = 0 ;
3986 char *kwnames[] = {
3987 (char *) "name",(char *) "type", NULL
3988 };
3989
3990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
3991 {
3992 arg1 = wxString_in_helper(obj0);
3993 if (arg1 == NULL) SWIG_fail;
3994 temp1 = true;
3995 }
3996 if (obj1) {
3997 {
3998 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
3999 if (SWIG_arg_fail(2)) SWIG_fail;
4000 }
4001 }
4002 {
4003 if (!wxPyCheckForApp()) SWIG_fail;
4004 PyThreadState* __tstate = wxPyBeginAllowThreads();
4005 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
4006
4007 wxPyEndAllowThreads(__tstate);
4008 if (PyErr_Occurred()) SWIG_fail;
4009 }
4010 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4011 {
4012 if (temp1)
4013 delete arg1;
4014 }
4015 return resultobj;
4016 fail:
4017 {
4018 if (temp1)
4019 delete arg1;
4020 }
4021 return NULL;
4022 }
4023
4024
4025 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4026 PyObject *resultobj;
4027 wxBitmap *arg1 = (wxBitmap *) 0 ;
4028 PyObject * obj0 = 0 ;
4029 char *kwnames[] = {
4030 (char *) "self", NULL
4031 };
4032
4033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
4034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4035 if (SWIG_arg_fail(1)) SWIG_fail;
4036 {
4037 PyThreadState* __tstate = wxPyBeginAllowThreads();
4038 delete arg1;
4039
4040 wxPyEndAllowThreads(__tstate);
4041 if (PyErr_Occurred()) SWIG_fail;
4042 }
4043 Py_INCREF(Py_None); resultobj = Py_None;
4044 return resultobj;
4045 fail:
4046 return NULL;
4047 }
4048
4049
4050 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4051 PyObject *resultobj;
4052 int arg1 ;
4053 int arg2 ;
4054 int arg3 = (int) -1 ;
4055 wxBitmap *result;
4056 PyObject * obj0 = 0 ;
4057 PyObject * obj1 = 0 ;
4058 PyObject * obj2 = 0 ;
4059 char *kwnames[] = {
4060 (char *) "width",(char *) "height",(char *) "depth", NULL
4061 };
4062
4063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4064 {
4065 arg1 = (int)(SWIG_As_int(obj0));
4066 if (SWIG_arg_fail(1)) SWIG_fail;
4067 }
4068 {
4069 arg2 = (int)(SWIG_As_int(obj1));
4070 if (SWIG_arg_fail(2)) SWIG_fail;
4071 }
4072 if (obj2) {
4073 {
4074 arg3 = (int)(SWIG_As_int(obj2));
4075 if (SWIG_arg_fail(3)) SWIG_fail;
4076 }
4077 }
4078 {
4079 if (!wxPyCheckForApp()) SWIG_fail;
4080 PyThreadState* __tstate = wxPyBeginAllowThreads();
4081 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4082
4083 wxPyEndAllowThreads(__tstate);
4084 if (PyErr_Occurred()) SWIG_fail;
4085 }
4086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4087 return resultobj;
4088 fail:
4089 return NULL;
4090 }
4091
4092
4093 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4094 PyObject *resultobj;
4095 wxIcon *arg1 = 0 ;
4096 wxBitmap *result;
4097 PyObject * obj0 = 0 ;
4098 char *kwnames[] = {
4099 (char *) "icon", NULL
4100 };
4101
4102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4103 {
4104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4105 if (SWIG_arg_fail(1)) SWIG_fail;
4106 if (arg1 == NULL) {
4107 SWIG_null_ref("wxIcon");
4108 }
4109 if (SWIG_arg_fail(1)) SWIG_fail;
4110 }
4111 {
4112 if (!wxPyCheckForApp()) SWIG_fail;
4113 PyThreadState* __tstate = wxPyBeginAllowThreads();
4114 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4115
4116 wxPyEndAllowThreads(__tstate);
4117 if (PyErr_Occurred()) SWIG_fail;
4118 }
4119 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4120 return resultobj;
4121 fail:
4122 return NULL;
4123 }
4124
4125
4126 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4127 PyObject *resultobj;
4128 wxImage *arg1 = 0 ;
4129 int arg2 = (int) -1 ;
4130 wxBitmap *result;
4131 PyObject * obj0 = 0 ;
4132 PyObject * obj1 = 0 ;
4133 char *kwnames[] = {
4134 (char *) "image",(char *) "depth", NULL
4135 };
4136
4137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4138 {
4139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4140 if (SWIG_arg_fail(1)) SWIG_fail;
4141 if (arg1 == NULL) {
4142 SWIG_null_ref("wxImage");
4143 }
4144 if (SWIG_arg_fail(1)) SWIG_fail;
4145 }
4146 if (obj1) {
4147 {
4148 arg2 = (int)(SWIG_As_int(obj1));
4149 if (SWIG_arg_fail(2)) SWIG_fail;
4150 }
4151 }
4152 {
4153 if (!wxPyCheckForApp()) SWIG_fail;
4154 PyThreadState* __tstate = wxPyBeginAllowThreads();
4155 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4156
4157 wxPyEndAllowThreads(__tstate);
4158 if (PyErr_Occurred()) SWIG_fail;
4159 }
4160 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4161 return resultobj;
4162 fail:
4163 return NULL;
4164 }
4165
4166
4167 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4168 PyObject *resultobj;
4169 PyObject *arg1 = (PyObject *) 0 ;
4170 wxBitmap *result;
4171 PyObject * obj0 = 0 ;
4172 char *kwnames[] = {
4173 (char *) "listOfStrings", NULL
4174 };
4175
4176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4177 arg1 = obj0;
4178 {
4179 if (!wxPyCheckForApp()) SWIG_fail;
4180 PyThreadState* __tstate = wxPyBeginAllowThreads();
4181 result = (wxBitmap *)new_wxBitmap(arg1);
4182
4183 wxPyEndAllowThreads(__tstate);
4184 if (PyErr_Occurred()) SWIG_fail;
4185 }
4186 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4187 return resultobj;
4188 fail:
4189 return NULL;
4190 }
4191
4192
4193 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4194 PyObject *resultobj;
4195 PyObject *arg1 = (PyObject *) 0 ;
4196 int arg2 ;
4197 int arg3 ;
4198 int arg4 = (int) 1 ;
4199 wxBitmap *result;
4200 PyObject * obj0 = 0 ;
4201 PyObject * obj1 = 0 ;
4202 PyObject * obj2 = 0 ;
4203 PyObject * obj3 = 0 ;
4204 char *kwnames[] = {
4205 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4206 };
4207
4208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4209 arg1 = obj0;
4210 {
4211 arg2 = (int)(SWIG_As_int(obj1));
4212 if (SWIG_arg_fail(2)) SWIG_fail;
4213 }
4214 {
4215 arg3 = (int)(SWIG_As_int(obj2));
4216 if (SWIG_arg_fail(3)) SWIG_fail;
4217 }
4218 if (obj3) {
4219 {
4220 arg4 = (int)(SWIG_As_int(obj3));
4221 if (SWIG_arg_fail(4)) SWIG_fail;
4222 }
4223 }
4224 {
4225 if (!wxPyCheckForApp()) SWIG_fail;
4226 PyThreadState* __tstate = wxPyBeginAllowThreads();
4227 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4228
4229 wxPyEndAllowThreads(__tstate);
4230 if (PyErr_Occurred()) SWIG_fail;
4231 }
4232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4233 return resultobj;
4234 fail:
4235 return NULL;
4236 }
4237
4238
4239 static PyObject *_wrap_Bitmap_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
4240 PyObject *resultobj;
4241 wxBitmap *arg1 = (wxBitmap *) 0 ;
4242 long result;
4243 PyObject * obj0 = 0 ;
4244 char *kwnames[] = {
4245 (char *) "self", NULL
4246 };
4247
4248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHandle",kwnames,&obj0)) goto fail;
4249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4250 if (SWIG_arg_fail(1)) SWIG_fail;
4251 {
4252 PyThreadState* __tstate = wxPyBeginAllowThreads();
4253 result = (long)(arg1)->GetHandle();
4254
4255 wxPyEndAllowThreads(__tstate);
4256 if (PyErr_Occurred()) SWIG_fail;
4257 }
4258 {
4259 resultobj = SWIG_From_long((long)(result));
4260 }
4261 return resultobj;
4262 fail:
4263 return NULL;
4264 }
4265
4266
4267 static PyObject *_wrap_Bitmap_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
4268 PyObject *resultobj;
4269 wxBitmap *arg1 = (wxBitmap *) 0 ;
4270 long arg2 ;
4271 PyObject * obj0 = 0 ;
4272 PyObject * obj1 = 0 ;
4273 char *kwnames[] = {
4274 (char *) "self",(char *) "handle", NULL
4275 };
4276
4277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHandle",kwnames,&obj0,&obj1)) goto fail;
4278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4279 if (SWIG_arg_fail(1)) SWIG_fail;
4280 {
4281 arg2 = (long)(SWIG_As_long(obj1));
4282 if (SWIG_arg_fail(2)) SWIG_fail;
4283 }
4284 {
4285 PyThreadState* __tstate = wxPyBeginAllowThreads();
4286 wxBitmap_SetHandle(arg1,arg2);
4287
4288 wxPyEndAllowThreads(__tstate);
4289 if (PyErr_Occurred()) SWIG_fail;
4290 }
4291 Py_INCREF(Py_None); resultobj = Py_None;
4292 return resultobj;
4293 fail:
4294 return NULL;
4295 }
4296
4297
4298 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4299 PyObject *resultobj;
4300 wxBitmap *arg1 = (wxBitmap *) 0 ;
4301 bool result;
4302 PyObject * obj0 = 0 ;
4303 char *kwnames[] = {
4304 (char *) "self", NULL
4305 };
4306
4307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4309 if (SWIG_arg_fail(1)) SWIG_fail;
4310 {
4311 PyThreadState* __tstate = wxPyBeginAllowThreads();
4312 result = (bool)(arg1)->Ok();
4313
4314 wxPyEndAllowThreads(__tstate);
4315 if (PyErr_Occurred()) SWIG_fail;
4316 }
4317 {
4318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4319 }
4320 return resultobj;
4321 fail:
4322 return NULL;
4323 }
4324
4325
4326 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4327 PyObject *resultobj;
4328 wxBitmap *arg1 = (wxBitmap *) 0 ;
4329 int result;
4330 PyObject * obj0 = 0 ;
4331 char *kwnames[] = {
4332 (char *) "self", NULL
4333 };
4334
4335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4337 if (SWIG_arg_fail(1)) SWIG_fail;
4338 {
4339 PyThreadState* __tstate = wxPyBeginAllowThreads();
4340 result = (int)(arg1)->GetWidth();
4341
4342 wxPyEndAllowThreads(__tstate);
4343 if (PyErr_Occurred()) SWIG_fail;
4344 }
4345 {
4346 resultobj = SWIG_From_int((int)(result));
4347 }
4348 return resultobj;
4349 fail:
4350 return NULL;
4351 }
4352
4353
4354 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4355 PyObject *resultobj;
4356 wxBitmap *arg1 = (wxBitmap *) 0 ;
4357 int result;
4358 PyObject * obj0 = 0 ;
4359 char *kwnames[] = {
4360 (char *) "self", NULL
4361 };
4362
4363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4365 if (SWIG_arg_fail(1)) SWIG_fail;
4366 {
4367 PyThreadState* __tstate = wxPyBeginAllowThreads();
4368 result = (int)(arg1)->GetHeight();
4369
4370 wxPyEndAllowThreads(__tstate);
4371 if (PyErr_Occurred()) SWIG_fail;
4372 }
4373 {
4374 resultobj = SWIG_From_int((int)(result));
4375 }
4376 return resultobj;
4377 fail:
4378 return NULL;
4379 }
4380
4381
4382 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4383 PyObject *resultobj;
4384 wxBitmap *arg1 = (wxBitmap *) 0 ;
4385 int result;
4386 PyObject * obj0 = 0 ;
4387 char *kwnames[] = {
4388 (char *) "self", NULL
4389 };
4390
4391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4393 if (SWIG_arg_fail(1)) SWIG_fail;
4394 {
4395 PyThreadState* __tstate = wxPyBeginAllowThreads();
4396 result = (int)(arg1)->GetDepth();
4397
4398 wxPyEndAllowThreads(__tstate);
4399 if (PyErr_Occurred()) SWIG_fail;
4400 }
4401 {
4402 resultobj = SWIG_From_int((int)(result));
4403 }
4404 return resultobj;
4405 fail:
4406 return NULL;
4407 }
4408
4409
4410 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4411 PyObject *resultobj;
4412 wxBitmap *arg1 = (wxBitmap *) 0 ;
4413 wxSize result;
4414 PyObject * obj0 = 0 ;
4415 char *kwnames[] = {
4416 (char *) "self", NULL
4417 };
4418
4419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4421 if (SWIG_arg_fail(1)) SWIG_fail;
4422 {
4423 PyThreadState* __tstate = wxPyBeginAllowThreads();
4424 result = wxBitmap_GetSize(arg1);
4425
4426 wxPyEndAllowThreads(__tstate);
4427 if (PyErr_Occurred()) SWIG_fail;
4428 }
4429 {
4430 wxSize * resultptr;
4431 resultptr = new wxSize((wxSize &)(result));
4432 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4433 }
4434 return resultobj;
4435 fail:
4436 return NULL;
4437 }
4438
4439
4440 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4441 PyObject *resultobj;
4442 wxBitmap *arg1 = (wxBitmap *) 0 ;
4443 SwigValueWrapper<wxImage > result;
4444 PyObject * obj0 = 0 ;
4445 char *kwnames[] = {
4446 (char *) "self", NULL
4447 };
4448
4449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4451 if (SWIG_arg_fail(1)) SWIG_fail;
4452 {
4453 PyThreadState* __tstate = wxPyBeginAllowThreads();
4454 result = ((wxBitmap const *)arg1)->ConvertToImage();
4455
4456 wxPyEndAllowThreads(__tstate);
4457 if (PyErr_Occurred()) SWIG_fail;
4458 }
4459 {
4460 wxImage * resultptr;
4461 resultptr = new wxImage((wxImage &)(result));
4462 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4463 }
4464 return resultobj;
4465 fail:
4466 return NULL;
4467 }
4468
4469
4470 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4471 PyObject *resultobj;
4472 wxBitmap *arg1 = (wxBitmap *) 0 ;
4473 wxMask *result;
4474 PyObject * obj0 = 0 ;
4475 char *kwnames[] = {
4476 (char *) "self", NULL
4477 };
4478
4479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4481 if (SWIG_arg_fail(1)) SWIG_fail;
4482 {
4483 PyThreadState* __tstate = wxPyBeginAllowThreads();
4484 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4485
4486 wxPyEndAllowThreads(__tstate);
4487 if (PyErr_Occurred()) SWIG_fail;
4488 }
4489 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4490 return resultobj;
4491 fail:
4492 return NULL;
4493 }
4494
4495
4496 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4497 PyObject *resultobj;
4498 wxBitmap *arg1 = (wxBitmap *) 0 ;
4499 wxMask *arg2 = (wxMask *) 0 ;
4500 PyObject * obj0 = 0 ;
4501 PyObject * obj1 = 0 ;
4502 char *kwnames[] = {
4503 (char *) "self",(char *) "mask", NULL
4504 };
4505
4506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4508 if (SWIG_arg_fail(1)) SWIG_fail;
4509 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4510 if (SWIG_arg_fail(2)) SWIG_fail;
4511 {
4512 PyThreadState* __tstate = wxPyBeginAllowThreads();
4513 (arg1)->SetMask(arg2);
4514
4515 wxPyEndAllowThreads(__tstate);
4516 if (PyErr_Occurred()) SWIG_fail;
4517 }
4518 Py_INCREF(Py_None); resultobj = Py_None;
4519 return resultobj;
4520 fail:
4521 return NULL;
4522 }
4523
4524
4525 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4526 PyObject *resultobj;
4527 wxBitmap *arg1 = (wxBitmap *) 0 ;
4528 wxColour *arg2 = 0 ;
4529 wxColour temp2 ;
4530 PyObject * obj0 = 0 ;
4531 PyObject * obj1 = 0 ;
4532 char *kwnames[] = {
4533 (char *) "self",(char *) "colour", NULL
4534 };
4535
4536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4538 if (SWIG_arg_fail(1)) SWIG_fail;
4539 {
4540 arg2 = &temp2;
4541 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4542 }
4543 {
4544 PyThreadState* __tstate = wxPyBeginAllowThreads();
4545 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4546
4547 wxPyEndAllowThreads(__tstate);
4548 if (PyErr_Occurred()) SWIG_fail;
4549 }
4550 Py_INCREF(Py_None); resultobj = Py_None;
4551 return resultobj;
4552 fail:
4553 return NULL;
4554 }
4555
4556
4557 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4558 PyObject *resultobj;
4559 wxBitmap *arg1 = (wxBitmap *) 0 ;
4560 wxRect *arg2 = 0 ;
4561 SwigValueWrapper<wxBitmap > result;
4562 wxRect temp2 ;
4563 PyObject * obj0 = 0 ;
4564 PyObject * obj1 = 0 ;
4565 char *kwnames[] = {
4566 (char *) "self",(char *) "rect", NULL
4567 };
4568
4569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4571 if (SWIG_arg_fail(1)) SWIG_fail;
4572 {
4573 arg2 = &temp2;
4574 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4575 }
4576 {
4577 PyThreadState* __tstate = wxPyBeginAllowThreads();
4578 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4579
4580 wxPyEndAllowThreads(__tstate);
4581 if (PyErr_Occurred()) SWIG_fail;
4582 }
4583 {
4584 wxBitmap * resultptr;
4585 resultptr = new wxBitmap((wxBitmap &)(result));
4586 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4587 }
4588 return resultobj;
4589 fail:
4590 return NULL;
4591 }
4592
4593
4594 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4595 PyObject *resultobj;
4596 wxBitmap *arg1 = (wxBitmap *) 0 ;
4597 wxString *arg2 = 0 ;
4598 wxBitmapType arg3 ;
4599 wxPalette *arg4 = (wxPalette *) NULL ;
4600 bool result;
4601 bool temp2 = false ;
4602 PyObject * obj0 = 0 ;
4603 PyObject * obj1 = 0 ;
4604 PyObject * obj2 = 0 ;
4605 PyObject * obj3 = 0 ;
4606 char *kwnames[] = {
4607 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4608 };
4609
4610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4612 if (SWIG_arg_fail(1)) SWIG_fail;
4613 {
4614 arg2 = wxString_in_helper(obj1);
4615 if (arg2 == NULL) SWIG_fail;
4616 temp2 = true;
4617 }
4618 {
4619 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4620 if (SWIG_arg_fail(3)) SWIG_fail;
4621 }
4622 if (obj3) {
4623 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4624 if (SWIG_arg_fail(4)) SWIG_fail;
4625 }
4626 {
4627 PyThreadState* __tstate = wxPyBeginAllowThreads();
4628 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4629
4630 wxPyEndAllowThreads(__tstate);
4631 if (PyErr_Occurred()) SWIG_fail;
4632 }
4633 {
4634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4635 }
4636 {
4637 if (temp2)
4638 delete arg2;
4639 }
4640 return resultobj;
4641 fail:
4642 {
4643 if (temp2)
4644 delete arg2;
4645 }
4646 return NULL;
4647 }
4648
4649
4650 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4651 PyObject *resultobj;
4652 wxBitmap *arg1 = (wxBitmap *) 0 ;
4653 wxString *arg2 = 0 ;
4654 wxBitmapType arg3 ;
4655 bool result;
4656 bool temp2 = false ;
4657 PyObject * obj0 = 0 ;
4658 PyObject * obj1 = 0 ;
4659 PyObject * obj2 = 0 ;
4660 char *kwnames[] = {
4661 (char *) "self",(char *) "name",(char *) "type", NULL
4662 };
4663
4664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4666 if (SWIG_arg_fail(1)) SWIG_fail;
4667 {
4668 arg2 = wxString_in_helper(obj1);
4669 if (arg2 == NULL) SWIG_fail;
4670 temp2 = true;
4671 }
4672 {
4673 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4674 if (SWIG_arg_fail(3)) SWIG_fail;
4675 }
4676 {
4677 PyThreadState* __tstate = wxPyBeginAllowThreads();
4678 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4679
4680 wxPyEndAllowThreads(__tstate);
4681 if (PyErr_Occurred()) SWIG_fail;
4682 }
4683 {
4684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4685 }
4686 {
4687 if (temp2)
4688 delete arg2;
4689 }
4690 return resultobj;
4691 fail:
4692 {
4693 if (temp2)
4694 delete arg2;
4695 }
4696 return NULL;
4697 }
4698
4699
4700 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4701 PyObject *resultobj;
4702 wxBitmap *arg1 = (wxBitmap *) 0 ;
4703 wxPalette *result;
4704 PyObject * obj0 = 0 ;
4705 char *kwnames[] = {
4706 (char *) "self", NULL
4707 };
4708
4709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4711 if (SWIG_arg_fail(1)) SWIG_fail;
4712 {
4713 PyThreadState* __tstate = wxPyBeginAllowThreads();
4714 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4715
4716 wxPyEndAllowThreads(__tstate);
4717 if (PyErr_Occurred()) SWIG_fail;
4718 }
4719 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4720 return resultobj;
4721 fail:
4722 return NULL;
4723 }
4724
4725
4726 static PyObject *_wrap_Bitmap_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4727 PyObject *resultobj;
4728 wxBitmap *arg1 = (wxBitmap *) 0 ;
4729 wxPalette *arg2 = 0 ;
4730 PyObject * obj0 = 0 ;
4731 PyObject * obj1 = 0 ;
4732 char *kwnames[] = {
4733 (char *) "self",(char *) "palette", NULL
4734 };
4735
4736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetPalette",kwnames,&obj0,&obj1)) goto fail;
4737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4738 if (SWIG_arg_fail(1)) SWIG_fail;
4739 {
4740 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4741 if (SWIG_arg_fail(2)) SWIG_fail;
4742 if (arg2 == NULL) {
4743 SWIG_null_ref("wxPalette");
4744 }
4745 if (SWIG_arg_fail(2)) SWIG_fail;
4746 }
4747 {
4748 PyThreadState* __tstate = wxPyBeginAllowThreads();
4749 (arg1)->SetPalette((wxPalette const &)*arg2);
4750
4751 wxPyEndAllowThreads(__tstate);
4752 if (PyErr_Occurred()) SWIG_fail;
4753 }
4754 Py_INCREF(Py_None); resultobj = Py_None;
4755 return resultobj;
4756 fail:
4757 return NULL;
4758 }
4759
4760
4761 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4762 PyObject *resultobj;
4763 wxBitmap *arg1 = (wxBitmap *) 0 ;
4764 wxIcon *arg2 = 0 ;
4765 bool result;
4766 PyObject * obj0 = 0 ;
4767 PyObject * obj1 = 0 ;
4768 char *kwnames[] = {
4769 (char *) "self",(char *) "icon", NULL
4770 };
4771
4772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4774 if (SWIG_arg_fail(1)) SWIG_fail;
4775 {
4776 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4777 if (SWIG_arg_fail(2)) SWIG_fail;
4778 if (arg2 == NULL) {
4779 SWIG_null_ref("wxIcon");
4780 }
4781 if (SWIG_arg_fail(2)) SWIG_fail;
4782 }
4783 {
4784 PyThreadState* __tstate = wxPyBeginAllowThreads();
4785 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4786
4787 wxPyEndAllowThreads(__tstate);
4788 if (PyErr_Occurred()) SWIG_fail;
4789 }
4790 {
4791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4792 }
4793 return resultobj;
4794 fail:
4795 return NULL;
4796 }
4797
4798
4799 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4800 PyObject *resultobj;
4801 wxBitmap *arg1 = (wxBitmap *) 0 ;
4802 int arg2 ;
4803 PyObject * obj0 = 0 ;
4804 PyObject * obj1 = 0 ;
4805 char *kwnames[] = {
4806 (char *) "self",(char *) "height", NULL
4807 };
4808
4809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4811 if (SWIG_arg_fail(1)) SWIG_fail;
4812 {
4813 arg2 = (int)(SWIG_As_int(obj1));
4814 if (SWIG_arg_fail(2)) SWIG_fail;
4815 }
4816 {
4817 PyThreadState* __tstate = wxPyBeginAllowThreads();
4818 (arg1)->SetHeight(arg2);
4819
4820 wxPyEndAllowThreads(__tstate);
4821 if (PyErr_Occurred()) SWIG_fail;
4822 }
4823 Py_INCREF(Py_None); resultobj = Py_None;
4824 return resultobj;
4825 fail:
4826 return NULL;
4827 }
4828
4829
4830 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4831 PyObject *resultobj;
4832 wxBitmap *arg1 = (wxBitmap *) 0 ;
4833 int arg2 ;
4834 PyObject * obj0 = 0 ;
4835 PyObject * obj1 = 0 ;
4836 char *kwnames[] = {
4837 (char *) "self",(char *) "width", NULL
4838 };
4839
4840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4842 if (SWIG_arg_fail(1)) SWIG_fail;
4843 {
4844 arg2 = (int)(SWIG_As_int(obj1));
4845 if (SWIG_arg_fail(2)) SWIG_fail;
4846 }
4847 {
4848 PyThreadState* __tstate = wxPyBeginAllowThreads();
4849 (arg1)->SetWidth(arg2);
4850
4851 wxPyEndAllowThreads(__tstate);
4852 if (PyErr_Occurred()) SWIG_fail;
4853 }
4854 Py_INCREF(Py_None); resultobj = Py_None;
4855 return resultobj;
4856 fail:
4857 return NULL;
4858 }
4859
4860
4861 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4862 PyObject *resultobj;
4863 wxBitmap *arg1 = (wxBitmap *) 0 ;
4864 int arg2 ;
4865 PyObject * obj0 = 0 ;
4866 PyObject * obj1 = 0 ;
4867 char *kwnames[] = {
4868 (char *) "self",(char *) "depth", NULL
4869 };
4870
4871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4873 if (SWIG_arg_fail(1)) SWIG_fail;
4874 {
4875 arg2 = (int)(SWIG_As_int(obj1));
4876 if (SWIG_arg_fail(2)) SWIG_fail;
4877 }
4878 {
4879 PyThreadState* __tstate = wxPyBeginAllowThreads();
4880 (arg1)->SetDepth(arg2);
4881
4882 wxPyEndAllowThreads(__tstate);
4883 if (PyErr_Occurred()) SWIG_fail;
4884 }
4885 Py_INCREF(Py_None); resultobj = Py_None;
4886 return resultobj;
4887 fail:
4888 return NULL;
4889 }
4890
4891
4892 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4893 PyObject *resultobj;
4894 wxBitmap *arg1 = (wxBitmap *) 0 ;
4895 wxSize *arg2 = 0 ;
4896 wxSize temp2 ;
4897 PyObject * obj0 = 0 ;
4898 PyObject * obj1 = 0 ;
4899 char *kwnames[] = {
4900 (char *) "self",(char *) "size", NULL
4901 };
4902
4903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4905 if (SWIG_arg_fail(1)) SWIG_fail;
4906 {
4907 arg2 = &temp2;
4908 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4909 }
4910 {
4911 PyThreadState* __tstate = wxPyBeginAllowThreads();
4912 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4913
4914 wxPyEndAllowThreads(__tstate);
4915 if (PyErr_Occurred()) SWIG_fail;
4916 }
4917 Py_INCREF(Py_None); resultobj = Py_None;
4918 return resultobj;
4919 fail:
4920 return NULL;
4921 }
4922
4923
4924 static PyObject *_wrap_Bitmap_CopyFromCursor(PyObject *, PyObject *args, PyObject *kwargs) {
4925 PyObject *resultobj;
4926 wxBitmap *arg1 = (wxBitmap *) 0 ;
4927 wxCursor *arg2 = 0 ;
4928 bool result;
4929 PyObject * obj0 = 0 ;
4930 PyObject * obj1 = 0 ;
4931 char *kwnames[] = {
4932 (char *) "self",(char *) "cursor", NULL
4933 };
4934
4935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromCursor",kwnames,&obj0,&obj1)) goto fail;
4936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4937 if (SWIG_arg_fail(1)) SWIG_fail;
4938 {
4939 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
4940 if (SWIG_arg_fail(2)) SWIG_fail;
4941 if (arg2 == NULL) {
4942 SWIG_null_ref("wxCursor");
4943 }
4944 if (SWIG_arg_fail(2)) SWIG_fail;
4945 }
4946 {
4947 PyThreadState* __tstate = wxPyBeginAllowThreads();
4948 result = (bool)(arg1)->CopyFromCursor((wxCursor const &)*arg2);
4949
4950 wxPyEndAllowThreads(__tstate);
4951 if (PyErr_Occurred()) SWIG_fail;
4952 }
4953 {
4954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4955 }
4956 return resultobj;
4957 fail:
4958 return NULL;
4959 }
4960
4961
4962 static PyObject *_wrap_Bitmap_GetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
4963 PyObject *resultobj;
4964 wxBitmap *arg1 = (wxBitmap *) 0 ;
4965 int result;
4966 PyObject * obj0 = 0 ;
4967 char *kwnames[] = {
4968 (char *) "self", NULL
4969 };
4970
4971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetQuality",kwnames,&obj0)) goto fail;
4972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4973 if (SWIG_arg_fail(1)) SWIG_fail;
4974 {
4975 PyThreadState* __tstate = wxPyBeginAllowThreads();
4976 result = (int)(arg1)->GetQuality();
4977
4978 wxPyEndAllowThreads(__tstate);
4979 if (PyErr_Occurred()) SWIG_fail;
4980 }
4981 {
4982 resultobj = SWIG_From_int((int)(result));
4983 }
4984 return resultobj;
4985 fail:
4986 return NULL;
4987 }
4988
4989
4990 static PyObject *_wrap_Bitmap_SetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
4991 PyObject *resultobj;
4992 wxBitmap *arg1 = (wxBitmap *) 0 ;
4993 int arg2 ;
4994 PyObject * obj0 = 0 ;
4995 PyObject * obj1 = 0 ;
4996 char *kwnames[] = {
4997 (char *) "self",(char *) "q", NULL
4998 };
4999
5000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetQuality",kwnames,&obj0,&obj1)) goto fail;
5001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5002 if (SWIG_arg_fail(1)) SWIG_fail;
5003 {
5004 arg2 = (int)(SWIG_As_int(obj1));
5005 if (SWIG_arg_fail(2)) SWIG_fail;
5006 }
5007 {
5008 PyThreadState* __tstate = wxPyBeginAllowThreads();
5009 (arg1)->SetQuality(arg2);
5010
5011 wxPyEndAllowThreads(__tstate);
5012 if (PyErr_Occurred()) SWIG_fail;
5013 }
5014 Py_INCREF(Py_None); resultobj = Py_None;
5015 return resultobj;
5016 fail:
5017 return NULL;
5018 }
5019
5020
5021 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5022 PyObject *resultobj;
5023 wxBitmap *arg1 = (wxBitmap *) 0 ;
5024 wxBitmap *arg2 = (wxBitmap *) 0 ;
5025 bool result;
5026 PyObject * obj0 = 0 ;
5027 PyObject * obj1 = 0 ;
5028 char *kwnames[] = {
5029 (char *) "self",(char *) "other", NULL
5030 };
5031
5032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
5033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5034 if (SWIG_arg_fail(1)) SWIG_fail;
5035 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5036 if (SWIG_arg_fail(2)) SWIG_fail;
5037 {
5038 PyThreadState* __tstate = wxPyBeginAllowThreads();
5039 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
5040
5041 wxPyEndAllowThreads(__tstate);
5042 if (PyErr_Occurred()) SWIG_fail;
5043 }
5044 {
5045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5046 }
5047 return resultobj;
5048 fail:
5049 return NULL;
5050 }
5051
5052
5053 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5054 PyObject *resultobj;
5055 wxBitmap *arg1 = (wxBitmap *) 0 ;
5056 wxBitmap *arg2 = (wxBitmap *) 0 ;
5057 bool result;
5058 PyObject * obj0 = 0 ;
5059 PyObject * obj1 = 0 ;
5060 char *kwnames[] = {
5061 (char *) "self",(char *) "other", NULL
5062 };
5063
5064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
5065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5066 if (SWIG_arg_fail(1)) SWIG_fail;
5067 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5068 if (SWIG_arg_fail(2)) SWIG_fail;
5069 {
5070 PyThreadState* __tstate = wxPyBeginAllowThreads();
5071 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
5072
5073 wxPyEndAllowThreads(__tstate);
5074 if (PyErr_Occurred()) SWIG_fail;
5075 }
5076 {
5077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5078 }
5079 return resultobj;
5080 fail:
5081 return NULL;
5082 }
5083
5084
5085 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
5086 PyObject *obj;
5087 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5088 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
5089 Py_INCREF(obj);
5090 return Py_BuildValue((char *)"");
5091 }
5092 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
5093 PyObject *resultobj;
5094 wxBitmap *arg1 = 0 ;
5095 wxColour const &arg2_defvalue = wxNullColour ;
5096 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
5097 wxMask *result;
5098 wxColour temp2 ;
5099 PyObject * obj0 = 0 ;
5100 PyObject * obj1 = 0 ;
5101 char *kwnames[] = {
5102 (char *) "bitmap",(char *) "colour", NULL
5103 };
5104
5105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
5106 {
5107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5108 if (SWIG_arg_fail(1)) SWIG_fail;
5109 if (arg1 == NULL) {
5110 SWIG_null_ref("wxBitmap");
5111 }
5112 if (SWIG_arg_fail(1)) SWIG_fail;
5113 }
5114 if (obj1) {
5115 {
5116 arg2 = &temp2;
5117 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5118 }
5119 }
5120 {
5121 if (!wxPyCheckForApp()) SWIG_fail;
5122 PyThreadState* __tstate = wxPyBeginAllowThreads();
5123 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
5124
5125 wxPyEndAllowThreads(__tstate);
5126 if (PyErr_Occurred()) SWIG_fail;
5127 }
5128 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
5129 return resultobj;
5130 fail:
5131 return NULL;
5132 }
5133
5134
5135 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
5136 PyObject *obj;
5137 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5138 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
5139 Py_INCREF(obj);
5140 return Py_BuildValue((char *)"");
5141 }
5142 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5143 PyObject *resultobj;
5144 wxString *arg1 = 0 ;
5145 wxBitmapType arg2 ;
5146 int arg3 = (int) -1 ;
5147 int arg4 = (int) -1 ;
5148 wxIcon *result;
5149 bool temp1 = false ;
5150 PyObject * obj0 = 0 ;
5151 PyObject * obj1 = 0 ;
5152 PyObject * obj2 = 0 ;
5153 PyObject * obj3 = 0 ;
5154 char *kwnames[] = {
5155 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
5156 };
5157
5158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5159 {
5160 arg1 = wxString_in_helper(obj0);
5161 if (arg1 == NULL) SWIG_fail;
5162 temp1 = true;
5163 }
5164 {
5165 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
5166 if (SWIG_arg_fail(2)) SWIG_fail;
5167 }
5168 if (obj2) {
5169 {
5170 arg3 = (int)(SWIG_As_int(obj2));
5171 if (SWIG_arg_fail(3)) SWIG_fail;
5172 }
5173 }
5174 if (obj3) {
5175 {
5176 arg4 = (int)(SWIG_As_int(obj3));
5177 if (SWIG_arg_fail(4)) SWIG_fail;
5178 }
5179 }
5180 {
5181 if (!wxPyCheckForApp()) SWIG_fail;
5182 PyThreadState* __tstate = wxPyBeginAllowThreads();
5183 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
5184
5185 wxPyEndAllowThreads(__tstate);
5186 if (PyErr_Occurred()) SWIG_fail;
5187 }
5188 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5189 {
5190 if (temp1)
5191 delete arg1;
5192 }
5193 return resultobj;
5194 fail:
5195 {
5196 if (temp1)
5197 delete arg1;
5198 }
5199 return NULL;
5200 }
5201
5202
5203 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5204 PyObject *resultobj;
5205 wxIcon *arg1 = (wxIcon *) 0 ;
5206 PyObject * obj0 = 0 ;
5207 char *kwnames[] = {
5208 (char *) "self", NULL
5209 };
5210
5211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
5212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5213 if (SWIG_arg_fail(1)) SWIG_fail;
5214 {
5215 PyThreadState* __tstate = wxPyBeginAllowThreads();
5216 delete arg1;
5217
5218 wxPyEndAllowThreads(__tstate);
5219 if (PyErr_Occurred()) SWIG_fail;
5220 }
5221 Py_INCREF(Py_None); resultobj = Py_None;
5222 return resultobj;
5223 fail:
5224 return NULL;
5225 }
5226
5227
5228 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5229 PyObject *resultobj;
5230 wxIcon *result;
5231 char *kwnames[] = {
5232 NULL
5233 };
5234
5235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5236 {
5237 if (!wxPyCheckForApp()) SWIG_fail;
5238 PyThreadState* __tstate = wxPyBeginAllowThreads();
5239 result = (wxIcon *)new wxIcon();
5240
5241 wxPyEndAllowThreads(__tstate);
5242 if (PyErr_Occurred()) SWIG_fail;
5243 }
5244 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5245 return resultobj;
5246 fail:
5247 return NULL;
5248 }
5249
5250
5251 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5252 PyObject *resultobj;
5253 wxIconLocation *arg1 = 0 ;
5254 wxIcon *result;
5255 PyObject * obj0 = 0 ;
5256 char *kwnames[] = {
5257 (char *) "loc", NULL
5258 };
5259
5260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5261 {
5262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5263 if (SWIG_arg_fail(1)) SWIG_fail;
5264 if (arg1 == NULL) {
5265 SWIG_null_ref("wxIconLocation");
5266 }
5267 if (SWIG_arg_fail(1)) SWIG_fail;
5268 }
5269 {
5270 if (!wxPyCheckForApp()) SWIG_fail;
5271 PyThreadState* __tstate = wxPyBeginAllowThreads();
5272 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5273
5274 wxPyEndAllowThreads(__tstate);
5275 if (PyErr_Occurred()) SWIG_fail;
5276 }
5277 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5278 return resultobj;
5279 fail:
5280 return NULL;
5281 }
5282
5283
5284 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5285 PyObject *resultobj;
5286 wxBitmap *arg1 = 0 ;
5287 wxIcon *result;
5288 PyObject * obj0 = 0 ;
5289 char *kwnames[] = {
5290 (char *) "bmp", NULL
5291 };
5292
5293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5294 {
5295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5296 if (SWIG_arg_fail(1)) SWIG_fail;
5297 if (arg1 == NULL) {
5298 SWIG_null_ref("wxBitmap");
5299 }
5300 if (SWIG_arg_fail(1)) SWIG_fail;
5301 }
5302 {
5303 if (!wxPyCheckForApp()) SWIG_fail;
5304 PyThreadState* __tstate = wxPyBeginAllowThreads();
5305 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5306
5307 wxPyEndAllowThreads(__tstate);
5308 if (PyErr_Occurred()) SWIG_fail;
5309 }
5310 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5311 return resultobj;
5312 fail:
5313 return NULL;
5314 }
5315
5316
5317 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5318 PyObject *resultobj;
5319 PyObject *arg1 = (PyObject *) 0 ;
5320 wxIcon *result;
5321 PyObject * obj0 = 0 ;
5322 char *kwnames[] = {
5323 (char *) "listOfStrings", NULL
5324 };
5325
5326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5327 arg1 = obj0;
5328 {
5329 if (!wxPyCheckForApp()) SWIG_fail;
5330 PyThreadState* __tstate = wxPyBeginAllowThreads();
5331 result = (wxIcon *)new_wxIcon(arg1);
5332
5333 wxPyEndAllowThreads(__tstate);
5334 if (PyErr_Occurred()) SWIG_fail;
5335 }
5336 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5337 return resultobj;
5338 fail:
5339 return NULL;
5340 }
5341
5342
5343 static PyObject *_wrap_Icon_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
5344 PyObject *resultobj;
5345 wxIcon *arg1 = (wxIcon *) 0 ;
5346 wxString *arg2 = 0 ;
5347 wxBitmapType arg3 ;
5348 bool result;
5349 bool temp2 = false ;
5350 PyObject * obj0 = 0 ;
5351 PyObject * obj1 = 0 ;
5352 PyObject * obj2 = 0 ;
5353 char *kwnames[] = {
5354 (char *) "self",(char *) "name",(char *) "type", NULL
5355 };
5356
5357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Icon_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5359 if (SWIG_arg_fail(1)) SWIG_fail;
5360 {
5361 arg2 = wxString_in_helper(obj1);
5362 if (arg2 == NULL) SWIG_fail;
5363 temp2 = true;
5364 }
5365 {
5366 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
5367 if (SWIG_arg_fail(3)) SWIG_fail;
5368 }
5369 {
5370 PyThreadState* __tstate = wxPyBeginAllowThreads();
5371 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
5372
5373 wxPyEndAllowThreads(__tstate);
5374 if (PyErr_Occurred()) SWIG_fail;
5375 }
5376 {
5377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5378 }
5379 {
5380 if (temp2)
5381 delete arg2;
5382 }
5383 return resultobj;
5384 fail:
5385 {
5386 if (temp2)
5387 delete arg2;
5388 }
5389 return NULL;
5390 }
5391
5392
5393 static PyObject *_wrap_Icon_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
5394 PyObject *resultobj;
5395 wxIcon *arg1 = (wxIcon *) 0 ;
5396 long result;
5397 PyObject * obj0 = 0 ;
5398 char *kwnames[] = {
5399 (char *) "self", NULL
5400 };
5401
5402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHandle",kwnames,&obj0)) goto fail;
5403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5404 if (SWIG_arg_fail(1)) SWIG_fail;
5405 {
5406 PyThreadState* __tstate = wxPyBeginAllowThreads();
5407 result = (long)(arg1)->GetHandle();
5408
5409 wxPyEndAllowThreads(__tstate);
5410 if (PyErr_Occurred()) SWIG_fail;
5411 }
5412 {
5413 resultobj = SWIG_From_long((long)(result));
5414 }
5415 return resultobj;
5416 fail:
5417 return NULL;
5418 }
5419
5420
5421 static PyObject *_wrap_Icon_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
5422 PyObject *resultobj;
5423 wxIcon *arg1 = (wxIcon *) 0 ;
5424 long arg2 ;
5425 PyObject * obj0 = 0 ;
5426 PyObject * obj1 = 0 ;
5427 char *kwnames[] = {
5428 (char *) "self",(char *) "handle", NULL
5429 };
5430
5431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHandle",kwnames,&obj0,&obj1)) goto fail;
5432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5433 if (SWIG_arg_fail(1)) SWIG_fail;
5434 {
5435 arg2 = (long)(SWIG_As_long(obj1));
5436 if (SWIG_arg_fail(2)) SWIG_fail;
5437 }
5438 {
5439 PyThreadState* __tstate = wxPyBeginAllowThreads();
5440 wxIcon_SetHandle(arg1,arg2);
5441
5442 wxPyEndAllowThreads(__tstate);
5443 if (PyErr_Occurred()) SWIG_fail;
5444 }
5445 Py_INCREF(Py_None); resultobj = Py_None;
5446 return resultobj;
5447 fail:
5448 return NULL;
5449 }
5450
5451
5452 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5453 PyObject *resultobj;
5454 wxIcon *arg1 = (wxIcon *) 0 ;
5455 bool result;
5456 PyObject * obj0 = 0 ;
5457 char *kwnames[] = {
5458 (char *) "self", NULL
5459 };
5460
5461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5463 if (SWIG_arg_fail(1)) SWIG_fail;
5464 {
5465 PyThreadState* __tstate = wxPyBeginAllowThreads();
5466 result = (bool)(arg1)->Ok();
5467
5468 wxPyEndAllowThreads(__tstate);
5469 if (PyErr_Occurred()) SWIG_fail;
5470 }
5471 {
5472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5473 }
5474 return resultobj;
5475 fail:
5476 return NULL;
5477 }
5478
5479
5480 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5481 PyObject *resultobj;
5482 wxIcon *arg1 = (wxIcon *) 0 ;
5483 int result;
5484 PyObject * obj0 = 0 ;
5485 char *kwnames[] = {
5486 (char *) "self", NULL
5487 };
5488
5489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5491 if (SWIG_arg_fail(1)) SWIG_fail;
5492 {
5493 PyThreadState* __tstate = wxPyBeginAllowThreads();
5494 result = (int)(arg1)->GetWidth();
5495
5496 wxPyEndAllowThreads(__tstate);
5497 if (PyErr_Occurred()) SWIG_fail;
5498 }
5499 {
5500 resultobj = SWIG_From_int((int)(result));
5501 }
5502 return resultobj;
5503 fail:
5504 return NULL;
5505 }
5506
5507
5508 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5509 PyObject *resultobj;
5510 wxIcon *arg1 = (wxIcon *) 0 ;
5511 int result;
5512 PyObject * obj0 = 0 ;
5513 char *kwnames[] = {
5514 (char *) "self", NULL
5515 };
5516
5517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5519 if (SWIG_arg_fail(1)) SWIG_fail;
5520 {
5521 PyThreadState* __tstate = wxPyBeginAllowThreads();
5522 result = (int)(arg1)->GetHeight();
5523
5524 wxPyEndAllowThreads(__tstate);
5525 if (PyErr_Occurred()) SWIG_fail;
5526 }
5527 {
5528 resultobj = SWIG_From_int((int)(result));
5529 }
5530 return resultobj;
5531 fail:
5532 return NULL;
5533 }
5534
5535
5536 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5537 PyObject *resultobj;
5538 wxIcon *arg1 = (wxIcon *) 0 ;
5539 int result;
5540 PyObject * obj0 = 0 ;
5541 char *kwnames[] = {
5542 (char *) "self", NULL
5543 };
5544
5545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5547 if (SWIG_arg_fail(1)) SWIG_fail;
5548 {
5549 PyThreadState* __tstate = wxPyBeginAllowThreads();
5550 result = (int)(arg1)->GetDepth();
5551
5552 wxPyEndAllowThreads(__tstate);
5553 if (PyErr_Occurred()) SWIG_fail;
5554 }
5555 {
5556 resultobj = SWIG_From_int((int)(result));
5557 }
5558 return resultobj;
5559 fail:
5560 return NULL;
5561 }
5562
5563
5564 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5565 PyObject *resultobj;
5566 wxIcon *arg1 = (wxIcon *) 0 ;
5567 int arg2 ;
5568 PyObject * obj0 = 0 ;
5569 PyObject * obj1 = 0 ;
5570 char *kwnames[] = {
5571 (char *) "self",(char *) "w", NULL
5572 };
5573
5574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5576 if (SWIG_arg_fail(1)) SWIG_fail;
5577 {
5578 arg2 = (int)(SWIG_As_int(obj1));
5579 if (SWIG_arg_fail(2)) SWIG_fail;
5580 }
5581 {
5582 PyThreadState* __tstate = wxPyBeginAllowThreads();
5583 (arg1)->SetWidth(arg2);
5584
5585 wxPyEndAllowThreads(__tstate);
5586 if (PyErr_Occurred()) SWIG_fail;
5587 }
5588 Py_INCREF(Py_None); resultobj = Py_None;
5589 return resultobj;
5590 fail:
5591 return NULL;
5592 }
5593
5594
5595 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5596 PyObject *resultobj;
5597 wxIcon *arg1 = (wxIcon *) 0 ;
5598 int arg2 ;
5599 PyObject * obj0 = 0 ;
5600 PyObject * obj1 = 0 ;
5601 char *kwnames[] = {
5602 (char *) "self",(char *) "h", NULL
5603 };
5604
5605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5607 if (SWIG_arg_fail(1)) SWIG_fail;
5608 {
5609 arg2 = (int)(SWIG_As_int(obj1));
5610 if (SWIG_arg_fail(2)) SWIG_fail;
5611 }
5612 {
5613 PyThreadState* __tstate = wxPyBeginAllowThreads();
5614 (arg1)->SetHeight(arg2);
5615
5616 wxPyEndAllowThreads(__tstate);
5617 if (PyErr_Occurred()) SWIG_fail;
5618 }
5619 Py_INCREF(Py_None); resultobj = Py_None;
5620 return resultobj;
5621 fail:
5622 return NULL;
5623 }
5624
5625
5626 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5627 PyObject *resultobj;
5628 wxIcon *arg1 = (wxIcon *) 0 ;
5629 int arg2 ;
5630 PyObject * obj0 = 0 ;
5631 PyObject * obj1 = 0 ;
5632 char *kwnames[] = {
5633 (char *) "self",(char *) "d", NULL
5634 };
5635
5636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5638 if (SWIG_arg_fail(1)) SWIG_fail;
5639 {
5640 arg2 = (int)(SWIG_As_int(obj1));
5641 if (SWIG_arg_fail(2)) SWIG_fail;
5642 }
5643 {
5644 PyThreadState* __tstate = wxPyBeginAllowThreads();
5645 (arg1)->SetDepth(arg2);
5646
5647 wxPyEndAllowThreads(__tstate);
5648 if (PyErr_Occurred()) SWIG_fail;
5649 }
5650 Py_INCREF(Py_None); resultobj = Py_None;
5651 return resultobj;
5652 fail:
5653 return NULL;
5654 }
5655
5656
5657 static PyObject *_wrap_Icon_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5658 PyObject *resultobj;
5659 wxIcon *arg1 = (wxIcon *) 0 ;
5660 wxSize *arg2 = 0 ;
5661 wxSize temp2 ;
5662 PyObject * obj0 = 0 ;
5663 PyObject * obj1 = 0 ;
5664 char *kwnames[] = {
5665 (char *) "self",(char *) "size", NULL
5666 };
5667
5668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetSize",kwnames,&obj0,&obj1)) goto fail;
5669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5670 if (SWIG_arg_fail(1)) SWIG_fail;
5671 {
5672 arg2 = &temp2;
5673 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5674 }
5675 {
5676 PyThreadState* __tstate = wxPyBeginAllowThreads();
5677 (arg1)->SetSize((wxSize const &)*arg2);
5678
5679 wxPyEndAllowThreads(__tstate);
5680 if (PyErr_Occurred()) SWIG_fail;
5681 }
5682 Py_INCREF(Py_None); resultobj = Py_None;
5683 return resultobj;
5684 fail:
5685 return NULL;
5686 }
5687
5688
5689 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5690 PyObject *resultobj;
5691 wxIcon *arg1 = (wxIcon *) 0 ;
5692 wxBitmap *arg2 = 0 ;
5693 PyObject * obj0 = 0 ;
5694 PyObject * obj1 = 0 ;
5695 char *kwnames[] = {
5696 (char *) "self",(char *) "bmp", NULL
5697 };
5698
5699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5701 if (SWIG_arg_fail(1)) SWIG_fail;
5702 {
5703 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5704 if (SWIG_arg_fail(2)) SWIG_fail;
5705 if (arg2 == NULL) {
5706 SWIG_null_ref("wxBitmap");
5707 }
5708 if (SWIG_arg_fail(2)) SWIG_fail;
5709 }
5710 {
5711 PyThreadState* __tstate = wxPyBeginAllowThreads();
5712 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5713
5714 wxPyEndAllowThreads(__tstate);
5715 if (PyErr_Occurred()) SWIG_fail;
5716 }
5717 Py_INCREF(Py_None); resultobj = Py_None;
5718 return resultobj;
5719 fail:
5720 return NULL;
5721 }
5722
5723
5724 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5725 PyObject *obj;
5726 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5727 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5728 Py_INCREF(obj);
5729 return Py_BuildValue((char *)"");
5730 }
5731 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5732 PyObject *resultobj;
5733 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5734 int arg2 = (int) 0 ;
5735 wxIconLocation *result;
5736 bool temp1 = false ;
5737 PyObject * obj0 = 0 ;
5738 PyObject * obj1 = 0 ;
5739 char *kwnames[] = {
5740 (char *) "filename",(char *) "num", NULL
5741 };
5742
5743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5744 if (obj0) {
5745 {
5746 arg1 = wxString_in_helper(obj0);
5747 if (arg1 == NULL) SWIG_fail;
5748 temp1 = true;
5749 }
5750 }
5751 if (obj1) {
5752 {
5753 arg2 = (int)(SWIG_As_int(obj1));
5754 if (SWIG_arg_fail(2)) SWIG_fail;
5755 }
5756 }
5757 {
5758 PyThreadState* __tstate = wxPyBeginAllowThreads();
5759 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5760
5761 wxPyEndAllowThreads(__tstate);
5762 if (PyErr_Occurred()) SWIG_fail;
5763 }
5764 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5765 {
5766 if (temp1)
5767 delete arg1;
5768 }
5769 return resultobj;
5770 fail:
5771 {
5772 if (temp1)
5773 delete arg1;
5774 }
5775 return NULL;
5776 }
5777
5778
5779 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5780 PyObject *resultobj;
5781 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5782 PyObject * obj0 = 0 ;
5783 char *kwnames[] = {
5784 (char *) "self", NULL
5785 };
5786
5787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5789 if (SWIG_arg_fail(1)) SWIG_fail;
5790 {
5791 PyThreadState* __tstate = wxPyBeginAllowThreads();
5792 delete arg1;
5793
5794 wxPyEndAllowThreads(__tstate);
5795 if (PyErr_Occurred()) SWIG_fail;
5796 }
5797 Py_INCREF(Py_None); resultobj = Py_None;
5798 return resultobj;
5799 fail:
5800 return NULL;
5801 }
5802
5803
5804 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5805 PyObject *resultobj;
5806 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5807 bool result;
5808 PyObject * obj0 = 0 ;
5809 char *kwnames[] = {
5810 (char *) "self", NULL
5811 };
5812
5813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5815 if (SWIG_arg_fail(1)) SWIG_fail;
5816 {
5817 PyThreadState* __tstate = wxPyBeginAllowThreads();
5818 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5819
5820 wxPyEndAllowThreads(__tstate);
5821 if (PyErr_Occurred()) SWIG_fail;
5822 }
5823 {
5824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5825 }
5826 return resultobj;
5827 fail:
5828 return NULL;
5829 }
5830
5831
5832 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5833 PyObject *resultobj;
5834 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5835 wxString *arg2 = 0 ;
5836 bool temp2 = false ;
5837 PyObject * obj0 = 0 ;
5838 PyObject * obj1 = 0 ;
5839 char *kwnames[] = {
5840 (char *) "self",(char *) "filename", NULL
5841 };
5842
5843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5845 if (SWIG_arg_fail(1)) SWIG_fail;
5846 {
5847 arg2 = wxString_in_helper(obj1);
5848 if (arg2 == NULL) SWIG_fail;
5849 temp2 = true;
5850 }
5851 {
5852 PyThreadState* __tstate = wxPyBeginAllowThreads();
5853 (arg1)->SetFileName((wxString const &)*arg2);
5854
5855 wxPyEndAllowThreads(__tstate);
5856 if (PyErr_Occurred()) SWIG_fail;
5857 }
5858 Py_INCREF(Py_None); resultobj = Py_None;
5859 {
5860 if (temp2)
5861 delete arg2;
5862 }
5863 return resultobj;
5864 fail:
5865 {
5866 if (temp2)
5867 delete arg2;
5868 }
5869 return NULL;
5870 }
5871
5872
5873 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5874 PyObject *resultobj;
5875 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5876 wxString *result;
5877 PyObject * obj0 = 0 ;
5878 char *kwnames[] = {
5879 (char *) "self", NULL
5880 };
5881
5882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5884 if (SWIG_arg_fail(1)) SWIG_fail;
5885 {
5886 PyThreadState* __tstate = wxPyBeginAllowThreads();
5887 {
5888 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5889 result = (wxString *) &_result_ref;
5890 }
5891
5892 wxPyEndAllowThreads(__tstate);
5893 if (PyErr_Occurred()) SWIG_fail;
5894 }
5895 {
5896 #if wxUSE_UNICODE
5897 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5898 #else
5899 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5900 #endif
5901 }
5902 return resultobj;
5903 fail:
5904 return NULL;
5905 }
5906
5907
5908 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5909 PyObject *resultobj;
5910 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5911 int arg2 ;
5912 PyObject * obj0 = 0 ;
5913 PyObject * obj1 = 0 ;
5914 char *kwnames[] = {
5915 (char *) "self",(char *) "num", NULL
5916 };
5917
5918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5920 if (SWIG_arg_fail(1)) SWIG_fail;
5921 {
5922 arg2 = (int)(SWIG_As_int(obj1));
5923 if (SWIG_arg_fail(2)) SWIG_fail;
5924 }
5925 {
5926 PyThreadState* __tstate = wxPyBeginAllowThreads();
5927 wxIconLocation_SetIndex(arg1,arg2);
5928
5929 wxPyEndAllowThreads(__tstate);
5930 if (PyErr_Occurred()) SWIG_fail;
5931 }
5932 Py_INCREF(Py_None); resultobj = Py_None;
5933 return resultobj;
5934 fail:
5935 return NULL;
5936 }
5937
5938
5939 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5940 PyObject *resultobj;
5941 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5942 int result;
5943 PyObject * obj0 = 0 ;
5944 char *kwnames[] = {
5945 (char *) "self", NULL
5946 };
5947
5948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5950 if (SWIG_arg_fail(1)) SWIG_fail;
5951 {
5952 PyThreadState* __tstate = wxPyBeginAllowThreads();
5953 result = (int)wxIconLocation_GetIndex(arg1);
5954
5955 wxPyEndAllowThreads(__tstate);
5956 if (PyErr_Occurred()) SWIG_fail;
5957 }
5958 {
5959 resultobj = SWIG_From_int((int)(result));
5960 }
5961 return resultobj;
5962 fail:
5963 return NULL;
5964 }
5965
5966
5967 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5968 PyObject *obj;
5969 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5970 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5971 Py_INCREF(obj);
5972 return Py_BuildValue((char *)"");
5973 }
5974 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5975 PyObject *resultobj;
5976 wxIconBundle *result;
5977 char *kwnames[] = {
5978 NULL
5979 };
5980
5981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5982 {
5983 PyThreadState* __tstate = wxPyBeginAllowThreads();
5984 result = (wxIconBundle *)new wxIconBundle();
5985
5986 wxPyEndAllowThreads(__tstate);
5987 if (PyErr_Occurred()) SWIG_fail;
5988 }
5989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5990 return resultobj;
5991 fail:
5992 return NULL;
5993 }
5994
5995
5996 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5997 PyObject *resultobj;
5998 wxString *arg1 = 0 ;
5999 long arg2 ;
6000 wxIconBundle *result;
6001 bool temp1 = false ;
6002 PyObject * obj0 = 0 ;
6003 PyObject * obj1 = 0 ;
6004 char *kwnames[] = {
6005 (char *) "file",(char *) "type", NULL
6006 };
6007
6008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
6009 {
6010 arg1 = wxString_in_helper(obj0);
6011 if (arg1 == NULL) SWIG_fail;
6012 temp1 = true;
6013 }
6014 {
6015 arg2 = (long)(SWIG_As_long(obj1));
6016 if (SWIG_arg_fail(2)) SWIG_fail;
6017 }
6018 {
6019 PyThreadState* __tstate = wxPyBeginAllowThreads();
6020 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
6021
6022 wxPyEndAllowThreads(__tstate);
6023 if (PyErr_Occurred()) SWIG_fail;
6024 }
6025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
6026 {
6027 if (temp1)
6028 delete arg1;
6029 }
6030 return resultobj;
6031 fail:
6032 {
6033 if (temp1)
6034 delete arg1;
6035 }
6036 return NULL;
6037 }
6038
6039
6040 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6041 PyObject *resultobj;
6042 wxIcon *arg1 = 0 ;
6043 wxIconBundle *result;
6044 PyObject * obj0 = 0 ;
6045 char *kwnames[] = {
6046 (char *) "icon", NULL
6047 };
6048
6049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
6050 {
6051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
6052 if (SWIG_arg_fail(1)) SWIG_fail;
6053 if (arg1 == NULL) {
6054 SWIG_null_ref("wxIcon");
6055 }
6056 if (SWIG_arg_fail(1)) SWIG_fail;
6057 }
6058 {
6059 PyThreadState* __tstate = wxPyBeginAllowThreads();
6060 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
6061
6062 wxPyEndAllowThreads(__tstate);
6063 if (PyErr_Occurred()) SWIG_fail;
6064 }
6065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
6066 return resultobj;
6067 fail:
6068 return NULL;
6069 }
6070
6071
6072 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
6073 PyObject *resultobj;
6074 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6075 PyObject * obj0 = 0 ;
6076 char *kwnames[] = {
6077 (char *) "self", NULL
6078 };
6079
6080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
6081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6082 if (SWIG_arg_fail(1)) SWIG_fail;
6083 {
6084 PyThreadState* __tstate = wxPyBeginAllowThreads();
6085 delete arg1;
6086
6087 wxPyEndAllowThreads(__tstate);
6088 if (PyErr_Occurred()) SWIG_fail;
6089 }
6090 Py_INCREF(Py_None); resultobj = Py_None;
6091 return resultobj;
6092 fail:
6093 return NULL;
6094 }
6095
6096
6097 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6098 PyObject *resultobj;
6099 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6100 wxIcon *arg2 = 0 ;
6101 PyObject * obj0 = 0 ;
6102 PyObject * obj1 = 0 ;
6103 char *kwnames[] = {
6104 (char *) "self",(char *) "icon", NULL
6105 };
6106
6107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
6108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6109 if (SWIG_arg_fail(1)) SWIG_fail;
6110 {
6111 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
6112 if (SWIG_arg_fail(2)) SWIG_fail;
6113 if (arg2 == NULL) {
6114 SWIG_null_ref("wxIcon");
6115 }
6116 if (SWIG_arg_fail(2)) SWIG_fail;
6117 }
6118 {
6119 PyThreadState* __tstate = wxPyBeginAllowThreads();
6120 (arg1)->AddIcon((wxIcon const &)*arg2);
6121
6122 wxPyEndAllowThreads(__tstate);
6123 if (PyErr_Occurred()) SWIG_fail;
6124 }
6125 Py_INCREF(Py_None); resultobj = Py_None;
6126 return resultobj;
6127 fail:
6128 return NULL;
6129 }
6130
6131
6132 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
6133 PyObject *resultobj;
6134 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6135 wxString *arg2 = 0 ;
6136 long arg3 ;
6137 bool temp2 = false ;
6138 PyObject * obj0 = 0 ;
6139 PyObject * obj1 = 0 ;
6140 PyObject * obj2 = 0 ;
6141 char *kwnames[] = {
6142 (char *) "self",(char *) "file",(char *) "type", NULL
6143 };
6144
6145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
6146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6147 if (SWIG_arg_fail(1)) SWIG_fail;
6148 {
6149 arg2 = wxString_in_helper(obj1);
6150 if (arg2 == NULL) SWIG_fail;
6151 temp2 = true;
6152 }
6153 {
6154 arg3 = (long)(SWIG_As_long(obj2));
6155 if (SWIG_arg_fail(3)) SWIG_fail;
6156 }
6157 {
6158 PyThreadState* __tstate = wxPyBeginAllowThreads();
6159 (arg1)->AddIcon((wxString const &)*arg2,arg3);
6160
6161 wxPyEndAllowThreads(__tstate);
6162 if (PyErr_Occurred()) SWIG_fail;
6163 }
6164 Py_INCREF(Py_None); resultobj = Py_None;
6165 {
6166 if (temp2)
6167 delete arg2;
6168 }
6169 return resultobj;
6170 fail:
6171 {
6172 if (temp2)
6173 delete arg2;
6174 }
6175 return NULL;
6176 }
6177
6178
6179 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6180 PyObject *resultobj;
6181 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6182 wxSize *arg2 = 0 ;
6183 wxIcon *result;
6184 wxSize temp2 ;
6185 PyObject * obj0 = 0 ;
6186 PyObject * obj1 = 0 ;
6187 char *kwnames[] = {
6188 (char *) "self",(char *) "size", NULL
6189 };
6190
6191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
6192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6193 if (SWIG_arg_fail(1)) SWIG_fail;
6194 {
6195 arg2 = &temp2;
6196 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6197 }
6198 {
6199 PyThreadState* __tstate = wxPyBeginAllowThreads();
6200 {
6201 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
6202 result = (wxIcon *) &_result_ref;
6203 }
6204
6205 wxPyEndAllowThreads(__tstate);
6206 if (PyErr_Occurred()) SWIG_fail;
6207 }
6208 {
6209 wxIcon* resultptr = new wxIcon(*result);
6210 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
6211 }
6212 return resultobj;
6213 fail:
6214 return NULL;
6215 }
6216
6217
6218 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
6219 PyObject *obj;
6220 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6221 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
6222 Py_INCREF(obj);
6223 return Py_BuildValue((char *)"");
6224 }
6225 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6226 PyObject *resultobj;
6227 wxString *arg1 = 0 ;
6228 long arg2 ;
6229 int arg3 = (int) 0 ;
6230 int arg4 = (int) 0 ;
6231 wxCursor *result;
6232 bool temp1 = false ;
6233 PyObject * obj0 = 0 ;
6234 PyObject * obj1 = 0 ;
6235 PyObject * obj2 = 0 ;
6236 PyObject * obj3 = 0 ;
6237 char *kwnames[] = {
6238 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
6239 };
6240
6241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6242 {
6243 arg1 = wxString_in_helper(obj0);
6244 if (arg1 == NULL) SWIG_fail;
6245 temp1 = true;
6246 }
6247 {
6248 arg2 = (long)(SWIG_As_long(obj1));
6249 if (SWIG_arg_fail(2)) SWIG_fail;
6250 }
6251 if (obj2) {
6252 {
6253 arg3 = (int)(SWIG_As_int(obj2));
6254 if (SWIG_arg_fail(3)) SWIG_fail;
6255 }
6256 }
6257 if (obj3) {
6258 {
6259 arg4 = (int)(SWIG_As_int(obj3));
6260 if (SWIG_arg_fail(4)) SWIG_fail;
6261 }
6262 }
6263 {
6264 if (!wxPyCheckForApp()) SWIG_fail;
6265 PyThreadState* __tstate = wxPyBeginAllowThreads();
6266 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
6267
6268 wxPyEndAllowThreads(__tstate);
6269 if (PyErr_Occurred()) SWIG_fail;
6270 }
6271 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6272 {
6273 if (temp1)
6274 delete arg1;
6275 }
6276 return resultobj;
6277 fail:
6278 {
6279 if (temp1)
6280 delete arg1;
6281 }
6282 return NULL;
6283 }
6284
6285
6286 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6287 PyObject *resultobj;
6288 wxCursor *arg1 = (wxCursor *) 0 ;
6289 PyObject * obj0 = 0 ;
6290 char *kwnames[] = {
6291 (char *) "self", NULL
6292 };
6293
6294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
6295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6296 if (SWIG_arg_fail(1)) SWIG_fail;
6297 {
6298 PyThreadState* __tstate = wxPyBeginAllowThreads();
6299 delete arg1;
6300
6301 wxPyEndAllowThreads(__tstate);
6302 if (PyErr_Occurred()) SWIG_fail;
6303 }
6304 Py_INCREF(Py_None); resultobj = Py_None;
6305 return resultobj;
6306 fail:
6307 return NULL;
6308 }
6309
6310
6311 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6312 PyObject *resultobj;
6313 int arg1 ;
6314 wxCursor *result;
6315 PyObject * obj0 = 0 ;
6316 char *kwnames[] = {
6317 (char *) "id", NULL
6318 };
6319
6320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
6321 {
6322 arg1 = (int)(SWIG_As_int(obj0));
6323 if (SWIG_arg_fail(1)) SWIG_fail;
6324 }
6325 {
6326 if (!wxPyCheckForApp()) SWIG_fail;
6327 PyThreadState* __tstate = wxPyBeginAllowThreads();
6328 result = (wxCursor *)new wxCursor(arg1);
6329
6330 wxPyEndAllowThreads(__tstate);
6331 if (PyErr_Occurred()) SWIG_fail;
6332 }
6333 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6334 return resultobj;
6335 fail:
6336 return NULL;
6337 }
6338
6339
6340 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6341 PyObject *resultobj;
6342 wxImage *arg1 = 0 ;
6343 wxCursor *result;
6344 PyObject * obj0 = 0 ;
6345 char *kwnames[] = {
6346 (char *) "image", NULL
6347 };
6348
6349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6350 {
6351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6352 if (SWIG_arg_fail(1)) SWIG_fail;
6353 if (arg1 == NULL) {
6354 SWIG_null_ref("wxImage");
6355 }
6356 if (SWIG_arg_fail(1)) SWIG_fail;
6357 }
6358 {
6359 if (!wxPyCheckForApp()) SWIG_fail;
6360 PyThreadState* __tstate = wxPyBeginAllowThreads();
6361 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6362
6363 wxPyEndAllowThreads(__tstate);
6364 if (PyErr_Occurred()) SWIG_fail;
6365 }
6366 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6367 return resultobj;
6368 fail:
6369 return NULL;
6370 }
6371
6372
6373 static PyObject *_wrap_Cursor_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
6374 PyObject *resultobj;
6375 wxCursor *arg1 = (wxCursor *) 0 ;
6376 long result;
6377 PyObject * obj0 = 0 ;
6378 char *kwnames[] = {
6379 (char *) "self", NULL
6380 };
6381
6382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetHandle",kwnames,&obj0)) goto fail;
6383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6384 if (SWIG_arg_fail(1)) SWIG_fail;
6385 {
6386 PyThreadState* __tstate = wxPyBeginAllowThreads();
6387 result = (long)(arg1)->GetHandle();
6388
6389 wxPyEndAllowThreads(__tstate);
6390 if (PyErr_Occurred()) SWIG_fail;
6391 }
6392 {
6393 resultobj = SWIG_From_long((long)(result));
6394 }
6395 return resultobj;
6396 fail:
6397 return NULL;
6398 }
6399
6400
6401 static PyObject *_wrap_Cursor_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
6402 PyObject *resultobj;
6403 wxCursor *arg1 = (wxCursor *) 0 ;
6404 long arg2 ;
6405 PyObject * obj0 = 0 ;
6406 PyObject * obj1 = 0 ;
6407 char *kwnames[] = {
6408 (char *) "self",(char *) "handle", NULL
6409 };
6410
6411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetHandle",kwnames,&obj0,&obj1)) goto fail;
6412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6413 if (SWIG_arg_fail(1)) SWIG_fail;
6414 {
6415 arg2 = (long)(SWIG_As_long(obj1));
6416 if (SWIG_arg_fail(2)) SWIG_fail;
6417 }
6418 {
6419 PyThreadState* __tstate = wxPyBeginAllowThreads();
6420 wxCursor_SetHandle(arg1,arg2);
6421
6422 wxPyEndAllowThreads(__tstate);
6423 if (PyErr_Occurred()) SWIG_fail;
6424 }
6425 Py_INCREF(Py_None); resultobj = Py_None;
6426 return resultobj;
6427 fail:
6428 return NULL;
6429 }
6430
6431
6432 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6433 PyObject *resultobj;
6434 wxCursor *arg1 = (wxCursor *) 0 ;
6435 bool result;
6436 PyObject * obj0 = 0 ;
6437 char *kwnames[] = {
6438 (char *) "self", NULL
6439 };
6440
6441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6443 if (SWIG_arg_fail(1)) SWIG_fail;
6444 {
6445 PyThreadState* __tstate = wxPyBeginAllowThreads();
6446 result = (bool)(arg1)->Ok();
6447
6448 wxPyEndAllowThreads(__tstate);
6449 if (PyErr_Occurred()) SWIG_fail;
6450 }
6451 {
6452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6453 }
6454 return resultobj;
6455 fail:
6456 return NULL;
6457 }
6458
6459
6460 static PyObject *_wrap_Cursor_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
6461 PyObject *resultobj;
6462 wxCursor *arg1 = (wxCursor *) 0 ;
6463 int result;
6464 PyObject * obj0 = 0 ;
6465 char *kwnames[] = {
6466 (char *) "self", NULL
6467 };
6468
6469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetWidth",kwnames,&obj0)) goto fail;
6470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6471 if (SWIG_arg_fail(1)) SWIG_fail;
6472 {
6473 PyThreadState* __tstate = wxPyBeginAllowThreads();
6474 result = (int)(arg1)->GetWidth();
6475
6476 wxPyEndAllowThreads(__tstate);
6477 if (PyErr_Occurred()) SWIG_fail;
6478 }
6479 {
6480 resultobj = SWIG_From_int((int)(result));
6481 }
6482 return resultobj;
6483 fail:
6484 return NULL;
6485 }
6486
6487
6488 static PyObject *_wrap_Cursor_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
6489 PyObject *resultobj;
6490 wxCursor *arg1 = (wxCursor *) 0 ;
6491 int result;
6492 PyObject * obj0 = 0 ;
6493 char *kwnames[] = {
6494 (char *) "self", NULL
6495 };
6496
6497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetHeight",kwnames,&obj0)) goto fail;
6498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6499 if (SWIG_arg_fail(1)) SWIG_fail;
6500 {
6501 PyThreadState* __tstate = wxPyBeginAllowThreads();
6502 result = (int)(arg1)->GetHeight();
6503
6504 wxPyEndAllowThreads(__tstate);
6505 if (PyErr_Occurred()) SWIG_fail;
6506 }
6507 {
6508 resultobj = SWIG_From_int((int)(result));
6509 }
6510 return resultobj;
6511 fail:
6512 return NULL;
6513 }
6514
6515
6516 static PyObject *_wrap_Cursor_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
6517 PyObject *resultobj;
6518 wxCursor *arg1 = (wxCursor *) 0 ;
6519 int result;
6520 PyObject * obj0 = 0 ;
6521 char *kwnames[] = {
6522 (char *) "self", NULL
6523 };
6524
6525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetDepth",kwnames,&obj0)) goto fail;
6526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6527 if (SWIG_arg_fail(1)) SWIG_fail;
6528 {
6529 PyThreadState* __tstate = wxPyBeginAllowThreads();
6530 result = (int)(arg1)->GetDepth();
6531
6532 wxPyEndAllowThreads(__tstate);
6533 if (PyErr_Occurred()) SWIG_fail;
6534 }
6535 {
6536 resultobj = SWIG_From_int((int)(result));
6537 }
6538 return resultobj;
6539 fail:
6540 return NULL;
6541 }
6542
6543
6544 static PyObject *_wrap_Cursor_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
6545 PyObject *resultobj;
6546 wxCursor *arg1 = (wxCursor *) 0 ;
6547 int arg2 ;
6548 PyObject * obj0 = 0 ;
6549 PyObject * obj1 = 0 ;
6550 char *kwnames[] = {
6551 (char *) "self",(char *) "w", NULL
6552 };
6553
6554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetWidth",kwnames,&obj0,&obj1)) goto fail;
6555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6556 if (SWIG_arg_fail(1)) SWIG_fail;
6557 {
6558 arg2 = (int)(SWIG_As_int(obj1));
6559 if (SWIG_arg_fail(2)) SWIG_fail;
6560 }
6561 {
6562 PyThreadState* __tstate = wxPyBeginAllowThreads();
6563 (arg1)->SetWidth(arg2);
6564
6565 wxPyEndAllowThreads(__tstate);
6566 if (PyErr_Occurred()) SWIG_fail;
6567 }
6568 Py_INCREF(Py_None); resultobj = Py_None;
6569 return resultobj;
6570 fail:
6571 return NULL;
6572 }
6573
6574
6575 static PyObject *_wrap_Cursor_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
6576 PyObject *resultobj;
6577 wxCursor *arg1 = (wxCursor *) 0 ;
6578 int arg2 ;
6579 PyObject * obj0 = 0 ;
6580 PyObject * obj1 = 0 ;
6581 char *kwnames[] = {
6582 (char *) "self",(char *) "h", NULL
6583 };
6584
6585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetHeight",kwnames,&obj0,&obj1)) goto fail;
6586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6587 if (SWIG_arg_fail(1)) SWIG_fail;
6588 {
6589 arg2 = (int)(SWIG_As_int(obj1));
6590 if (SWIG_arg_fail(2)) SWIG_fail;
6591 }
6592 {
6593 PyThreadState* __tstate = wxPyBeginAllowThreads();
6594 (arg1)->SetHeight(arg2);
6595
6596 wxPyEndAllowThreads(__tstate);
6597 if (PyErr_Occurred()) SWIG_fail;
6598 }
6599 Py_INCREF(Py_None); resultobj = Py_None;
6600 return resultobj;
6601 fail:
6602 return NULL;
6603 }
6604
6605
6606 static PyObject *_wrap_Cursor_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
6607 PyObject *resultobj;
6608 wxCursor *arg1 = (wxCursor *) 0 ;
6609 int arg2 ;
6610 PyObject * obj0 = 0 ;
6611 PyObject * obj1 = 0 ;
6612 char *kwnames[] = {
6613 (char *) "self",(char *) "d", NULL
6614 };
6615
6616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetDepth",kwnames,&obj0,&obj1)) goto fail;
6617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6618 if (SWIG_arg_fail(1)) SWIG_fail;
6619 {
6620 arg2 = (int)(SWIG_As_int(obj1));
6621 if (SWIG_arg_fail(2)) SWIG_fail;
6622 }
6623 {
6624 PyThreadState* __tstate = wxPyBeginAllowThreads();
6625 (arg1)->SetDepth(arg2);
6626
6627 wxPyEndAllowThreads(__tstate);
6628 if (PyErr_Occurred()) SWIG_fail;
6629 }
6630 Py_INCREF(Py_None); resultobj = Py_None;
6631 return resultobj;
6632 fail:
6633 return NULL;
6634 }
6635
6636
6637 static PyObject *_wrap_Cursor_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6638 PyObject *resultobj;
6639 wxCursor *arg1 = (wxCursor *) 0 ;
6640 wxSize *arg2 = 0 ;
6641 wxSize temp2 ;
6642 PyObject * obj0 = 0 ;
6643 PyObject * obj1 = 0 ;
6644 char *kwnames[] = {
6645 (char *) "self",(char *) "size", NULL
6646 };
6647
6648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetSize",kwnames,&obj0,&obj1)) goto fail;
6649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6650 if (SWIG_arg_fail(1)) SWIG_fail;
6651 {
6652 arg2 = &temp2;
6653 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6654 }
6655 {
6656 PyThreadState* __tstate = wxPyBeginAllowThreads();
6657 (arg1)->SetSize((wxSize const &)*arg2);
6658
6659 wxPyEndAllowThreads(__tstate);
6660 if (PyErr_Occurred()) SWIG_fail;
6661 }
6662 Py_INCREF(Py_None); resultobj = Py_None;
6663 return resultobj;
6664 fail:
6665 return NULL;
6666 }
6667
6668
6669 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6670 PyObject *obj;
6671 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6672 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6673 Py_INCREF(obj);
6674 return Py_BuildValue((char *)"");
6675 }
6676 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6677 PyObject *resultobj;
6678 int arg1 = (int) 0 ;
6679 int arg2 = (int) 0 ;
6680 int arg3 = (int) 0 ;
6681 int arg4 = (int) 0 ;
6682 wxRegion *result;
6683 PyObject * obj0 = 0 ;
6684 PyObject * obj1 = 0 ;
6685 PyObject * obj2 = 0 ;
6686 PyObject * obj3 = 0 ;
6687 char *kwnames[] = {
6688 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6689 };
6690
6691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6692 if (obj0) {
6693 {
6694 arg1 = (int)(SWIG_As_int(obj0));
6695 if (SWIG_arg_fail(1)) SWIG_fail;
6696 }
6697 }
6698 if (obj1) {
6699 {
6700 arg2 = (int)(SWIG_As_int(obj1));
6701 if (SWIG_arg_fail(2)) SWIG_fail;
6702 }
6703 }
6704 if (obj2) {
6705 {
6706 arg3 = (int)(SWIG_As_int(obj2));
6707 if (SWIG_arg_fail(3)) SWIG_fail;
6708 }
6709 }
6710 if (obj3) {
6711 {
6712 arg4 = (int)(SWIG_As_int(obj3));
6713 if (SWIG_arg_fail(4)) SWIG_fail;
6714 }
6715 }
6716 {
6717 if (!wxPyCheckForApp()) SWIG_fail;
6718 PyThreadState* __tstate = wxPyBeginAllowThreads();
6719 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6720
6721 wxPyEndAllowThreads(__tstate);
6722 if (PyErr_Occurred()) SWIG_fail;
6723 }
6724 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6725 return resultobj;
6726 fail:
6727 return NULL;
6728 }
6729
6730
6731 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6732 PyObject *resultobj;
6733 wxBitmap *arg1 = 0 ;
6734 wxRegion *result;
6735 PyObject * obj0 = 0 ;
6736 char *kwnames[] = {
6737 (char *) "bmp", NULL
6738 };
6739
6740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6741 {
6742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6743 if (SWIG_arg_fail(1)) SWIG_fail;
6744 if (arg1 == NULL) {
6745 SWIG_null_ref("wxBitmap");
6746 }
6747 if (SWIG_arg_fail(1)) SWIG_fail;
6748 }
6749 {
6750 if (!wxPyCheckForApp()) SWIG_fail;
6751 PyThreadState* __tstate = wxPyBeginAllowThreads();
6752 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6753
6754 wxPyEndAllowThreads(__tstate);
6755 if (PyErr_Occurred()) SWIG_fail;
6756 }
6757 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6758 return resultobj;
6759 fail:
6760 return NULL;
6761 }
6762
6763
6764 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6765 PyObject *resultobj;
6766 wxBitmap *arg1 = 0 ;
6767 wxColour *arg2 = 0 ;
6768 int arg3 = (int) 0 ;
6769 wxRegion *result;
6770 wxColour temp2 ;
6771 PyObject * obj0 = 0 ;
6772 PyObject * obj1 = 0 ;
6773 PyObject * obj2 = 0 ;
6774 char *kwnames[] = {
6775 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6776 };
6777
6778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6779 {
6780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6781 if (SWIG_arg_fail(1)) SWIG_fail;
6782 if (arg1 == NULL) {
6783 SWIG_null_ref("wxBitmap");
6784 }
6785 if (SWIG_arg_fail(1)) SWIG_fail;
6786 }
6787 {
6788 arg2 = &temp2;
6789 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6790 }
6791 if (obj2) {
6792 {
6793 arg3 = (int)(SWIG_As_int(obj2));
6794 if (SWIG_arg_fail(3)) SWIG_fail;
6795 }
6796 }
6797 {
6798 if (!wxPyCheckForApp()) SWIG_fail;
6799 PyThreadState* __tstate = wxPyBeginAllowThreads();
6800 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6801
6802 wxPyEndAllowThreads(__tstate);
6803 if (PyErr_Occurred()) SWIG_fail;
6804 }
6805 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6806 return resultobj;
6807 fail:
6808 return NULL;
6809 }
6810
6811
6812 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6813 PyObject *resultobj;
6814 int arg1 ;
6815 wxPoint *arg2 = (wxPoint *) 0 ;
6816 int arg3 = (int) wxWINDING_RULE ;
6817 wxRegion *result;
6818 PyObject * obj0 = 0 ;
6819 PyObject * obj1 = 0 ;
6820 char *kwnames[] = {
6821 (char *) "points",(char *) "fillStyle", NULL
6822 };
6823
6824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6825 {
6826 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6827 if (arg2 == NULL) SWIG_fail;
6828 }
6829 if (obj1) {
6830 {
6831 arg3 = (int)(SWIG_As_int(obj1));
6832 if (SWIG_arg_fail(3)) SWIG_fail;
6833 }
6834 }
6835 {
6836 if (!wxPyCheckForApp()) SWIG_fail;
6837 PyThreadState* __tstate = wxPyBeginAllowThreads();
6838 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6839
6840 wxPyEndAllowThreads(__tstate);
6841 if (PyErr_Occurred()) SWIG_fail;
6842 }
6843 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6844 {
6845 if (arg2) delete [] arg2;
6846 }
6847 return resultobj;
6848 fail:
6849 {
6850 if (arg2) delete [] arg2;
6851 }
6852 return NULL;
6853 }
6854
6855
6856 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6857 PyObject *resultobj;
6858 wxRegion *arg1 = (wxRegion *) 0 ;
6859 PyObject * obj0 = 0 ;
6860 char *kwnames[] = {
6861 (char *) "self", NULL
6862 };
6863
6864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6866 if (SWIG_arg_fail(1)) SWIG_fail;
6867 {
6868 PyThreadState* __tstate = wxPyBeginAllowThreads();
6869 delete arg1;
6870
6871 wxPyEndAllowThreads(__tstate);
6872 if (PyErr_Occurred()) SWIG_fail;
6873 }
6874 Py_INCREF(Py_None); resultobj = Py_None;
6875 return resultobj;
6876 fail:
6877 return NULL;
6878 }
6879
6880
6881 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6882 PyObject *resultobj;
6883 wxRegion *arg1 = (wxRegion *) 0 ;
6884 PyObject * obj0 = 0 ;
6885 char *kwnames[] = {
6886 (char *) "self", NULL
6887 };
6888
6889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6891 if (SWIG_arg_fail(1)) SWIG_fail;
6892 {
6893 PyThreadState* __tstate = wxPyBeginAllowThreads();
6894 (arg1)->Clear();
6895
6896 wxPyEndAllowThreads(__tstate);
6897 if (PyErr_Occurred()) SWIG_fail;
6898 }
6899 Py_INCREF(Py_None); resultobj = Py_None;
6900 return resultobj;
6901 fail:
6902 return NULL;
6903 }
6904
6905
6906 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6907 PyObject *resultobj;
6908 wxRegion *arg1 = (wxRegion *) 0 ;
6909 int arg2 ;
6910 int arg3 ;
6911 bool result;
6912 PyObject * obj0 = 0 ;
6913 PyObject * obj1 = 0 ;
6914 PyObject * obj2 = 0 ;
6915 char *kwnames[] = {
6916 (char *) "self",(char *) "x",(char *) "y", NULL
6917 };
6918
6919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6921 if (SWIG_arg_fail(1)) SWIG_fail;
6922 {
6923 arg2 = (int)(SWIG_As_int(obj1));
6924 if (SWIG_arg_fail(2)) SWIG_fail;
6925 }
6926 {
6927 arg3 = (int)(SWIG_As_int(obj2));
6928 if (SWIG_arg_fail(3)) SWIG_fail;
6929 }
6930 {
6931 PyThreadState* __tstate = wxPyBeginAllowThreads();
6932 result = (bool)(arg1)->Offset(arg2,arg3);
6933
6934 wxPyEndAllowThreads(__tstate);
6935 if (PyErr_Occurred()) SWIG_fail;
6936 }
6937 {
6938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6939 }
6940 return resultobj;
6941 fail:
6942 return NULL;
6943 }
6944
6945
6946 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6947 PyObject *resultobj;
6948 wxRegion *arg1 = (wxRegion *) 0 ;
6949 int arg2 ;
6950 int arg3 ;
6951 wxRegionContain result;
6952 PyObject * obj0 = 0 ;
6953 PyObject * obj1 = 0 ;
6954 PyObject * obj2 = 0 ;
6955 char *kwnames[] = {
6956 (char *) "self",(char *) "x",(char *) "y", NULL
6957 };
6958
6959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6961 if (SWIG_arg_fail(1)) SWIG_fail;
6962 {
6963 arg2 = (int)(SWIG_As_int(obj1));
6964 if (SWIG_arg_fail(2)) SWIG_fail;
6965 }
6966 {
6967 arg3 = (int)(SWIG_As_int(obj2));
6968 if (SWIG_arg_fail(3)) SWIG_fail;
6969 }
6970 {
6971 PyThreadState* __tstate = wxPyBeginAllowThreads();
6972 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6973
6974 wxPyEndAllowThreads(__tstate);
6975 if (PyErr_Occurred()) SWIG_fail;
6976 }
6977 resultobj = SWIG_From_int((result));
6978 return resultobj;
6979 fail:
6980 return NULL;
6981 }
6982
6983
6984 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6985 PyObject *resultobj;
6986 wxRegion *arg1 = (wxRegion *) 0 ;
6987 wxPoint *arg2 = 0 ;
6988 wxRegionContain result;
6989 wxPoint temp2 ;
6990 PyObject * obj0 = 0 ;
6991 PyObject * obj1 = 0 ;
6992 char *kwnames[] = {
6993 (char *) "self",(char *) "pt", NULL
6994 };
6995
6996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6998 if (SWIG_arg_fail(1)) SWIG_fail;
6999 {
7000 arg2 = &temp2;
7001 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7002 }
7003 {
7004 PyThreadState* __tstate = wxPyBeginAllowThreads();
7005 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
7006
7007 wxPyEndAllowThreads(__tstate);
7008 if (PyErr_Occurred()) SWIG_fail;
7009 }
7010 resultobj = SWIG_From_int((result));
7011 return resultobj;
7012 fail:
7013 return NULL;
7014 }
7015
7016
7017 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
7018 PyObject *resultobj;
7019 wxRegion *arg1 = (wxRegion *) 0 ;
7020 wxRect *arg2 = 0 ;
7021 wxRegionContain result;
7022 wxRect temp2 ;
7023 PyObject * obj0 = 0 ;
7024 PyObject * obj1 = 0 ;
7025 char *kwnames[] = {
7026 (char *) "self",(char *) "rect", NULL
7027 };
7028
7029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
7030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7031 if (SWIG_arg_fail(1)) SWIG_fail;
7032 {
7033 arg2 = &temp2;
7034 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7035 }
7036 {
7037 PyThreadState* __tstate = wxPyBeginAllowThreads();
7038 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
7039
7040 wxPyEndAllowThreads(__tstate);
7041 if (PyErr_Occurred()) SWIG_fail;
7042 }
7043 resultobj = SWIG_From_int((result));
7044 return resultobj;
7045 fail:
7046 return NULL;
7047 }
7048
7049
7050 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
7051 PyObject *resultobj;
7052 wxRegion *arg1 = (wxRegion *) 0 ;
7053 int arg2 ;
7054 int arg3 ;
7055 int arg4 ;
7056 int arg5 ;
7057 wxRegionContain result;
7058 PyObject * obj0 = 0 ;
7059 PyObject * obj1 = 0 ;
7060 PyObject * obj2 = 0 ;
7061 PyObject * obj3 = 0 ;
7062 PyObject * obj4 = 0 ;
7063 char *kwnames[] = {
7064 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
7065 };
7066
7067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7069 if (SWIG_arg_fail(1)) SWIG_fail;
7070 {
7071 arg2 = (int)(SWIG_As_int(obj1));
7072 if (SWIG_arg_fail(2)) SWIG_fail;
7073 }
7074 {
7075 arg3 = (int)(SWIG_As_int(obj2));
7076 if (SWIG_arg_fail(3)) SWIG_fail;
7077 }
7078 {
7079 arg4 = (int)(SWIG_As_int(obj3));
7080 if (SWIG_arg_fail(4)) SWIG_fail;
7081 }
7082 {
7083 arg5 = (int)(SWIG_As_int(obj4));
7084 if (SWIG_arg_fail(5)) SWIG_fail;
7085 }
7086 {
7087 PyThreadState* __tstate = wxPyBeginAllowThreads();
7088 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
7089
7090 wxPyEndAllowThreads(__tstate);
7091 if (PyErr_Occurred()) SWIG_fail;
7092 }
7093 resultobj = SWIG_From_int((result));
7094 return resultobj;
7095 fail:
7096 return NULL;
7097 }
7098
7099
7100 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
7101 PyObject *resultobj;
7102 wxRegion *arg1 = (wxRegion *) 0 ;
7103 wxRect result;
7104 PyObject * obj0 = 0 ;
7105 char *kwnames[] = {
7106 (char *) "self", NULL
7107 };
7108
7109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
7110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7111 if (SWIG_arg_fail(1)) SWIG_fail;
7112 {
7113 PyThreadState* __tstate = wxPyBeginAllowThreads();
7114 result = (arg1)->GetBox();
7115
7116 wxPyEndAllowThreads(__tstate);
7117 if (PyErr_Occurred()) SWIG_fail;
7118 }
7119 {
7120 wxRect * resultptr;
7121 resultptr = new wxRect((wxRect &)(result));
7122 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7123 }
7124 return resultobj;
7125 fail:
7126 return NULL;
7127 }
7128
7129
7130 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
7131 PyObject *resultobj;
7132 wxRegion *arg1 = (wxRegion *) 0 ;
7133 int arg2 ;
7134 int arg3 ;
7135 int arg4 ;
7136 int arg5 ;
7137 bool result;
7138 PyObject * obj0 = 0 ;
7139 PyObject * obj1 = 0 ;
7140 PyObject * obj2 = 0 ;
7141 PyObject * obj3 = 0 ;
7142 PyObject * obj4 = 0 ;
7143 char *kwnames[] = {
7144 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7145 };
7146
7147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7149 if (SWIG_arg_fail(1)) SWIG_fail;
7150 {
7151 arg2 = (int)(SWIG_As_int(obj1));
7152 if (SWIG_arg_fail(2)) SWIG_fail;
7153 }
7154 {
7155 arg3 = (int)(SWIG_As_int(obj2));
7156 if (SWIG_arg_fail(3)) SWIG_fail;
7157 }
7158 {
7159 arg4 = (int)(SWIG_As_int(obj3));
7160 if (SWIG_arg_fail(4)) SWIG_fail;
7161 }
7162 {
7163 arg5 = (int)(SWIG_As_int(obj4));
7164 if (SWIG_arg_fail(5)) SWIG_fail;
7165 }
7166 {
7167 PyThreadState* __tstate = wxPyBeginAllowThreads();
7168 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
7169
7170 wxPyEndAllowThreads(__tstate);
7171 if (PyErr_Occurred()) SWIG_fail;
7172 }
7173 {
7174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7175 }
7176 return resultobj;
7177 fail:
7178 return NULL;
7179 }
7180
7181
7182 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
7183 PyObject *resultobj;
7184 wxRegion *arg1 = (wxRegion *) 0 ;
7185 wxRect *arg2 = 0 ;
7186 bool result;
7187 wxRect temp2 ;
7188 PyObject * obj0 = 0 ;
7189 PyObject * obj1 = 0 ;
7190 char *kwnames[] = {
7191 (char *) "self",(char *) "rect", NULL
7192 };
7193
7194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
7195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7196 if (SWIG_arg_fail(1)) SWIG_fail;
7197 {
7198 arg2 = &temp2;
7199 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7200 }
7201 {
7202 PyThreadState* __tstate = wxPyBeginAllowThreads();
7203 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
7204
7205 wxPyEndAllowThreads(__tstate);
7206 if (PyErr_Occurred()) SWIG_fail;
7207 }
7208 {
7209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7210 }
7211 return resultobj;
7212 fail:
7213 return NULL;
7214 }
7215
7216
7217 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7218 PyObject *resultobj;
7219 wxRegion *arg1 = (wxRegion *) 0 ;
7220 wxRegion *arg2 = 0 ;
7221 bool result;
7222 PyObject * obj0 = 0 ;
7223 PyObject * obj1 = 0 ;
7224 char *kwnames[] = {
7225 (char *) "self",(char *) "region", NULL
7226 };
7227
7228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
7229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7230 if (SWIG_arg_fail(1)) SWIG_fail;
7231 {
7232 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7233 if (SWIG_arg_fail(2)) SWIG_fail;
7234 if (arg2 == NULL) {
7235 SWIG_null_ref("wxRegion");
7236 }
7237 if (SWIG_arg_fail(2)) SWIG_fail;
7238 }
7239 {
7240 PyThreadState* __tstate = wxPyBeginAllowThreads();
7241 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
7242
7243 wxPyEndAllowThreads(__tstate);
7244 if (PyErr_Occurred()) SWIG_fail;
7245 }
7246 {
7247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7248 }
7249 return resultobj;
7250 fail:
7251 return NULL;
7252 }
7253
7254
7255 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
7256 PyObject *resultobj;
7257 wxRegion *arg1 = (wxRegion *) 0 ;
7258 bool result;
7259 PyObject * obj0 = 0 ;
7260 char *kwnames[] = {
7261 (char *) "self", NULL
7262 };
7263
7264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
7265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7266 if (SWIG_arg_fail(1)) SWIG_fail;
7267 {
7268 PyThreadState* __tstate = wxPyBeginAllowThreads();
7269 result = (bool)(arg1)->IsEmpty();
7270
7271 wxPyEndAllowThreads(__tstate);
7272 if (PyErr_Occurred()) SWIG_fail;
7273 }
7274 {
7275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7276 }
7277 return resultobj;
7278 fail:
7279 return NULL;
7280 }
7281
7282
7283 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
7284 PyObject *resultobj;
7285 wxRegion *arg1 = (wxRegion *) 0 ;
7286 int arg2 ;
7287 int arg3 ;
7288 int arg4 ;
7289 int arg5 ;
7290 bool result;
7291 PyObject * obj0 = 0 ;
7292 PyObject * obj1 = 0 ;
7293 PyObject * obj2 = 0 ;
7294 PyObject * obj3 = 0 ;
7295 PyObject * obj4 = 0 ;
7296 char *kwnames[] = {
7297 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7298 };
7299
7300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7302 if (SWIG_arg_fail(1)) SWIG_fail;
7303 {
7304 arg2 = (int)(SWIG_As_int(obj1));
7305 if (SWIG_arg_fail(2)) SWIG_fail;
7306 }
7307 {
7308 arg3 = (int)(SWIG_As_int(obj2));
7309 if (SWIG_arg_fail(3)) SWIG_fail;
7310 }
7311 {
7312 arg4 = (int)(SWIG_As_int(obj3));
7313 if (SWIG_arg_fail(4)) SWIG_fail;
7314 }
7315 {
7316 arg5 = (int)(SWIG_As_int(obj4));
7317 if (SWIG_arg_fail(5)) SWIG_fail;
7318 }
7319 {
7320 PyThreadState* __tstate = wxPyBeginAllowThreads();
7321 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
7322
7323 wxPyEndAllowThreads(__tstate);
7324 if (PyErr_Occurred()) SWIG_fail;
7325 }
7326 {
7327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7328 }
7329 return resultobj;
7330 fail:
7331 return NULL;
7332 }
7333
7334
7335 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
7336 PyObject *resultobj;
7337 wxRegion *arg1 = (wxRegion *) 0 ;
7338 wxRect *arg2 = 0 ;
7339 bool result;
7340 wxRect temp2 ;
7341 PyObject * obj0 = 0 ;
7342 PyObject * obj1 = 0 ;
7343 char *kwnames[] = {
7344 (char *) "self",(char *) "rect", NULL
7345 };
7346
7347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
7348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7349 if (SWIG_arg_fail(1)) SWIG_fail;
7350 {
7351 arg2 = &temp2;
7352 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7353 }
7354 {
7355 PyThreadState* __tstate = wxPyBeginAllowThreads();
7356 result = (bool)(arg1)->Union((wxRect const &)*arg2);
7357
7358 wxPyEndAllowThreads(__tstate);
7359 if (PyErr_Occurred()) SWIG_fail;
7360 }
7361 {
7362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7363 }
7364 return resultobj;
7365 fail:
7366 return NULL;
7367 }
7368
7369
7370 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7371 PyObject *resultobj;
7372 wxRegion *arg1 = (wxRegion *) 0 ;
7373 wxRegion *arg2 = 0 ;
7374 bool result;
7375 PyObject * obj0 = 0 ;
7376 PyObject * obj1 = 0 ;
7377 char *kwnames[] = {
7378 (char *) "self",(char *) "region", NULL
7379 };
7380
7381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
7382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7383 if (SWIG_arg_fail(1)) SWIG_fail;
7384 {
7385 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7386 if (SWIG_arg_fail(2)) SWIG_fail;
7387 if (arg2 == NULL) {
7388 SWIG_null_ref("wxRegion");
7389 }
7390 if (SWIG_arg_fail(2)) SWIG_fail;
7391 }
7392 {
7393 PyThreadState* __tstate = wxPyBeginAllowThreads();
7394 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
7395
7396 wxPyEndAllowThreads(__tstate);
7397 if (PyErr_Occurred()) SWIG_fail;
7398 }
7399 {
7400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7401 }
7402 return resultobj;
7403 fail:
7404 return NULL;
7405 }
7406
7407
7408 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
7409 PyObject *resultobj;
7410 wxRegion *arg1 = (wxRegion *) 0 ;
7411 int arg2 ;
7412 int arg3 ;
7413 int arg4 ;
7414 int arg5 ;
7415 bool result;
7416 PyObject * obj0 = 0 ;
7417 PyObject * obj1 = 0 ;
7418 PyObject * obj2 = 0 ;
7419 PyObject * obj3 = 0 ;
7420 PyObject * obj4 = 0 ;
7421 char *kwnames[] = {
7422 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7423 };
7424
7425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7427 if (SWIG_arg_fail(1)) SWIG_fail;
7428 {
7429 arg2 = (int)(SWIG_As_int(obj1));
7430 if (SWIG_arg_fail(2)) SWIG_fail;
7431 }
7432 {
7433 arg3 = (int)(SWIG_As_int(obj2));
7434 if (SWIG_arg_fail(3)) SWIG_fail;
7435 }
7436 {
7437 arg4 = (int)(SWIG_As_int(obj3));
7438 if (SWIG_arg_fail(4)) SWIG_fail;
7439 }
7440 {
7441 arg5 = (int)(SWIG_As_int(obj4));
7442 if (SWIG_arg_fail(5)) SWIG_fail;
7443 }
7444 {
7445 PyThreadState* __tstate = wxPyBeginAllowThreads();
7446 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
7447
7448 wxPyEndAllowThreads(__tstate);
7449 if (PyErr_Occurred()) SWIG_fail;
7450 }
7451 {
7452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7453 }
7454 return resultobj;
7455 fail:
7456 return NULL;
7457 }
7458
7459
7460 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
7461 PyObject *resultobj;
7462 wxRegion *arg1 = (wxRegion *) 0 ;
7463 wxRect *arg2 = 0 ;
7464 bool result;
7465 wxRect temp2 ;
7466 PyObject * obj0 = 0 ;
7467 PyObject * obj1 = 0 ;
7468 char *kwnames[] = {
7469 (char *) "self",(char *) "rect", NULL
7470 };
7471
7472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
7473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7474 if (SWIG_arg_fail(1)) SWIG_fail;
7475 {
7476 arg2 = &temp2;
7477 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7478 }
7479 {
7480 PyThreadState* __tstate = wxPyBeginAllowThreads();
7481 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
7482
7483 wxPyEndAllowThreads(__tstate);
7484 if (PyErr_Occurred()) SWIG_fail;
7485 }
7486 {
7487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7488 }
7489 return resultobj;
7490 fail:
7491 return NULL;
7492 }
7493
7494
7495 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7496 PyObject *resultobj;
7497 wxRegion *arg1 = (wxRegion *) 0 ;
7498 wxRegion *arg2 = 0 ;
7499 bool result;
7500 PyObject * obj0 = 0 ;
7501 PyObject * obj1 = 0 ;
7502 char *kwnames[] = {
7503 (char *) "self",(char *) "region", NULL
7504 };
7505
7506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
7507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7508 if (SWIG_arg_fail(1)) SWIG_fail;
7509 {
7510 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7511 if (SWIG_arg_fail(2)) SWIG_fail;
7512 if (arg2 == NULL) {
7513 SWIG_null_ref("wxRegion");
7514 }
7515 if (SWIG_arg_fail(2)) SWIG_fail;
7516 }
7517 {
7518 PyThreadState* __tstate = wxPyBeginAllowThreads();
7519 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
7520
7521 wxPyEndAllowThreads(__tstate);
7522 if (PyErr_Occurred()) SWIG_fail;
7523 }
7524 {
7525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7526 }
7527 return resultobj;
7528 fail:
7529 return NULL;
7530 }
7531
7532
7533 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
7534 PyObject *resultobj;
7535 wxRegion *arg1 = (wxRegion *) 0 ;
7536 int arg2 ;
7537 int arg3 ;
7538 int arg4 ;
7539 int arg5 ;
7540 bool result;
7541 PyObject * obj0 = 0 ;
7542 PyObject * obj1 = 0 ;
7543 PyObject * obj2 = 0 ;
7544 PyObject * obj3 = 0 ;
7545 PyObject * obj4 = 0 ;
7546 char *kwnames[] = {
7547 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7548 };
7549
7550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7552 if (SWIG_arg_fail(1)) SWIG_fail;
7553 {
7554 arg2 = (int)(SWIG_As_int(obj1));
7555 if (SWIG_arg_fail(2)) SWIG_fail;
7556 }
7557 {
7558 arg3 = (int)(SWIG_As_int(obj2));
7559 if (SWIG_arg_fail(3)) SWIG_fail;
7560 }
7561 {
7562 arg4 = (int)(SWIG_As_int(obj3));
7563 if (SWIG_arg_fail(4)) SWIG_fail;
7564 }
7565 {
7566 arg5 = (int)(SWIG_As_int(obj4));
7567 if (SWIG_arg_fail(5)) SWIG_fail;
7568 }
7569 {
7570 PyThreadState* __tstate = wxPyBeginAllowThreads();
7571 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
7572
7573 wxPyEndAllowThreads(__tstate);
7574 if (PyErr_Occurred()) SWIG_fail;
7575 }
7576 {
7577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7578 }
7579 return resultobj;
7580 fail:
7581 return NULL;
7582 }
7583
7584
7585 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
7586 PyObject *resultobj;
7587 wxRegion *arg1 = (wxRegion *) 0 ;
7588 wxRect *arg2 = 0 ;
7589 bool result;
7590 wxRect temp2 ;
7591 PyObject * obj0 = 0 ;
7592 PyObject * obj1 = 0 ;
7593 char *kwnames[] = {
7594 (char *) "self",(char *) "rect", NULL
7595 };
7596
7597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7599 if (SWIG_arg_fail(1)) SWIG_fail;
7600 {
7601 arg2 = &temp2;
7602 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7603 }
7604 {
7605 PyThreadState* __tstate = wxPyBeginAllowThreads();
7606 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7607
7608 wxPyEndAllowThreads(__tstate);
7609 if (PyErr_Occurred()) SWIG_fail;
7610 }
7611 {
7612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7613 }
7614 return resultobj;
7615 fail:
7616 return NULL;
7617 }
7618
7619
7620 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7621 PyObject *resultobj;
7622 wxRegion *arg1 = (wxRegion *) 0 ;
7623 wxRegion *arg2 = 0 ;
7624 bool result;
7625 PyObject * obj0 = 0 ;
7626 PyObject * obj1 = 0 ;
7627 char *kwnames[] = {
7628 (char *) "self",(char *) "region", NULL
7629 };
7630
7631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7633 if (SWIG_arg_fail(1)) SWIG_fail;
7634 {
7635 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7636 if (SWIG_arg_fail(2)) SWIG_fail;
7637 if (arg2 == NULL) {
7638 SWIG_null_ref("wxRegion");
7639 }
7640 if (SWIG_arg_fail(2)) SWIG_fail;
7641 }
7642 {
7643 PyThreadState* __tstate = wxPyBeginAllowThreads();
7644 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7645
7646 wxPyEndAllowThreads(__tstate);
7647 if (PyErr_Occurred()) SWIG_fail;
7648 }
7649 {
7650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7651 }
7652 return resultobj;
7653 fail:
7654 return NULL;
7655 }
7656
7657
7658 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7659 PyObject *resultobj;
7660 wxRegion *arg1 = (wxRegion *) 0 ;
7661 SwigValueWrapper<wxBitmap > result;
7662 PyObject * obj0 = 0 ;
7663 char *kwnames[] = {
7664 (char *) "self", NULL
7665 };
7666
7667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7669 if (SWIG_arg_fail(1)) SWIG_fail;
7670 {
7671 PyThreadState* __tstate = wxPyBeginAllowThreads();
7672 result = (arg1)->ConvertToBitmap();
7673
7674 wxPyEndAllowThreads(__tstate);
7675 if (PyErr_Occurred()) SWIG_fail;
7676 }
7677 {
7678 wxBitmap * resultptr;
7679 resultptr = new wxBitmap((wxBitmap &)(result));
7680 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7681 }
7682 return resultobj;
7683 fail:
7684 return NULL;
7685 }
7686
7687
7688 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7689 PyObject *resultobj;
7690 wxRegion *arg1 = (wxRegion *) 0 ;
7691 wxBitmap *arg2 = 0 ;
7692 bool result;
7693 PyObject * obj0 = 0 ;
7694 PyObject * obj1 = 0 ;
7695 char *kwnames[] = {
7696 (char *) "self",(char *) "bmp", NULL
7697 };
7698
7699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7701 if (SWIG_arg_fail(1)) SWIG_fail;
7702 {
7703 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7704 if (SWIG_arg_fail(2)) SWIG_fail;
7705 if (arg2 == NULL) {
7706 SWIG_null_ref("wxBitmap");
7707 }
7708 if (SWIG_arg_fail(2)) SWIG_fail;
7709 }
7710 {
7711 PyThreadState* __tstate = wxPyBeginAllowThreads();
7712 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7713
7714 wxPyEndAllowThreads(__tstate);
7715 if (PyErr_Occurred()) SWIG_fail;
7716 }
7717 {
7718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7719 }
7720 return resultobj;
7721 fail:
7722 return NULL;
7723 }
7724
7725
7726 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7727 PyObject *resultobj;
7728 wxRegion *arg1 = (wxRegion *) 0 ;
7729 wxBitmap *arg2 = 0 ;
7730 wxColour *arg3 = 0 ;
7731 int arg4 = (int) 0 ;
7732 bool result;
7733 wxColour temp3 ;
7734 PyObject * obj0 = 0 ;
7735 PyObject * obj1 = 0 ;
7736 PyObject * obj2 = 0 ;
7737 PyObject * obj3 = 0 ;
7738 char *kwnames[] = {
7739 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7740 };
7741
7742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7744 if (SWIG_arg_fail(1)) SWIG_fail;
7745 {
7746 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7747 if (SWIG_arg_fail(2)) SWIG_fail;
7748 if (arg2 == NULL) {
7749 SWIG_null_ref("wxBitmap");
7750 }
7751 if (SWIG_arg_fail(2)) SWIG_fail;
7752 }
7753 {
7754 arg3 = &temp3;
7755 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7756 }
7757 if (obj3) {
7758 {
7759 arg4 = (int)(SWIG_As_int(obj3));
7760 if (SWIG_arg_fail(4)) SWIG_fail;
7761 }
7762 }
7763 {
7764 PyThreadState* __tstate = wxPyBeginAllowThreads();
7765 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7766
7767 wxPyEndAllowThreads(__tstate);
7768 if (PyErr_Occurred()) SWIG_fail;
7769 }
7770 {
7771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7772 }
7773 return resultobj;
7774 fail:
7775 return NULL;
7776 }
7777
7778
7779 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7780 PyObject *obj;
7781 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7782 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7783 Py_INCREF(obj);
7784 return Py_BuildValue((char *)"");
7785 }
7786 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7787 PyObject *resultobj;
7788 wxRegion *arg1 = 0 ;
7789 wxRegionIterator *result;
7790 PyObject * obj0 = 0 ;
7791 char *kwnames[] = {
7792 (char *) "region", NULL
7793 };
7794
7795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7796 {
7797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7798 if (SWIG_arg_fail(1)) SWIG_fail;
7799 if (arg1 == NULL) {
7800 SWIG_null_ref("wxRegion");
7801 }
7802 if (SWIG_arg_fail(1)) SWIG_fail;
7803 }
7804 {
7805 if (!wxPyCheckForApp()) SWIG_fail;
7806 PyThreadState* __tstate = wxPyBeginAllowThreads();
7807 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7808
7809 wxPyEndAllowThreads(__tstate);
7810 if (PyErr_Occurred()) SWIG_fail;
7811 }
7812 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7813 return resultobj;
7814 fail:
7815 return NULL;
7816 }
7817
7818
7819 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7820 PyObject *resultobj;
7821 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7822 PyObject * obj0 = 0 ;
7823 char *kwnames[] = {
7824 (char *) "self", NULL
7825 };
7826
7827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7829 if (SWIG_arg_fail(1)) SWIG_fail;
7830 {
7831 PyThreadState* __tstate = wxPyBeginAllowThreads();
7832 delete arg1;
7833
7834 wxPyEndAllowThreads(__tstate);
7835 if (PyErr_Occurred()) SWIG_fail;
7836 }
7837 Py_INCREF(Py_None); resultobj = Py_None;
7838 return resultobj;
7839 fail:
7840 return NULL;
7841 }
7842
7843
7844 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7845 PyObject *resultobj;
7846 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7847 int result;
7848 PyObject * obj0 = 0 ;
7849 char *kwnames[] = {
7850 (char *) "self", NULL
7851 };
7852
7853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7855 if (SWIG_arg_fail(1)) SWIG_fail;
7856 {
7857 PyThreadState* __tstate = wxPyBeginAllowThreads();
7858 result = (int)(arg1)->GetX();
7859
7860 wxPyEndAllowThreads(__tstate);
7861 if (PyErr_Occurred()) SWIG_fail;
7862 }
7863 {
7864 resultobj = SWIG_From_int((int)(result));
7865 }
7866 return resultobj;
7867 fail:
7868 return NULL;
7869 }
7870
7871
7872 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7873 PyObject *resultobj;
7874 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7875 int result;
7876 PyObject * obj0 = 0 ;
7877 char *kwnames[] = {
7878 (char *) "self", NULL
7879 };
7880
7881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7883 if (SWIG_arg_fail(1)) SWIG_fail;
7884 {
7885 PyThreadState* __tstate = wxPyBeginAllowThreads();
7886 result = (int)(arg1)->GetY();
7887
7888 wxPyEndAllowThreads(__tstate);
7889 if (PyErr_Occurred()) SWIG_fail;
7890 }
7891 {
7892 resultobj = SWIG_From_int((int)(result));
7893 }
7894 return resultobj;
7895 fail:
7896 return NULL;
7897 }
7898
7899
7900 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7901 PyObject *resultobj;
7902 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7903 int result;
7904 PyObject * obj0 = 0 ;
7905 char *kwnames[] = {
7906 (char *) "self", NULL
7907 };
7908
7909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7911 if (SWIG_arg_fail(1)) SWIG_fail;
7912 {
7913 PyThreadState* __tstate = wxPyBeginAllowThreads();
7914 result = (int)(arg1)->GetW();
7915
7916 wxPyEndAllowThreads(__tstate);
7917 if (PyErr_Occurred()) SWIG_fail;
7918 }
7919 {
7920 resultobj = SWIG_From_int((int)(result));
7921 }
7922 return resultobj;
7923 fail:
7924 return NULL;
7925 }
7926
7927
7928 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7929 PyObject *resultobj;
7930 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7931 int result;
7932 PyObject * obj0 = 0 ;
7933 char *kwnames[] = {
7934 (char *) "self", NULL
7935 };
7936
7937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7939 if (SWIG_arg_fail(1)) SWIG_fail;
7940 {
7941 PyThreadState* __tstate = wxPyBeginAllowThreads();
7942 result = (int)(arg1)->GetWidth();
7943
7944 wxPyEndAllowThreads(__tstate);
7945 if (PyErr_Occurred()) SWIG_fail;
7946 }
7947 {
7948 resultobj = SWIG_From_int((int)(result));
7949 }
7950 return resultobj;
7951 fail:
7952 return NULL;
7953 }
7954
7955
7956 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7957 PyObject *resultobj;
7958 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7959 int result;
7960 PyObject * obj0 = 0 ;
7961 char *kwnames[] = {
7962 (char *) "self", NULL
7963 };
7964
7965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7967 if (SWIG_arg_fail(1)) SWIG_fail;
7968 {
7969 PyThreadState* __tstate = wxPyBeginAllowThreads();
7970 result = (int)(arg1)->GetH();
7971
7972 wxPyEndAllowThreads(__tstate);
7973 if (PyErr_Occurred()) SWIG_fail;
7974 }
7975 {
7976 resultobj = SWIG_From_int((int)(result));
7977 }
7978 return resultobj;
7979 fail:
7980 return NULL;
7981 }
7982
7983
7984 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7985 PyObject *resultobj;
7986 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7987 int result;
7988 PyObject * obj0 = 0 ;
7989 char *kwnames[] = {
7990 (char *) "self", NULL
7991 };
7992
7993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7995 if (SWIG_arg_fail(1)) SWIG_fail;
7996 {
7997 PyThreadState* __tstate = wxPyBeginAllowThreads();
7998 result = (int)(arg1)->GetHeight();
7999
8000 wxPyEndAllowThreads(__tstate);
8001 if (PyErr_Occurred()) SWIG_fail;
8002 }
8003 {
8004 resultobj = SWIG_From_int((int)(result));
8005 }
8006 return resultobj;
8007 fail:
8008 return NULL;
8009 }
8010
8011
8012 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
8013 PyObject *resultobj;
8014 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8015 wxRect result;
8016 PyObject * obj0 = 0 ;
8017 char *kwnames[] = {
8018 (char *) "self", NULL
8019 };
8020
8021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
8022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8023 if (SWIG_arg_fail(1)) SWIG_fail;
8024 {
8025 PyThreadState* __tstate = wxPyBeginAllowThreads();
8026 result = (arg1)->GetRect();
8027
8028 wxPyEndAllowThreads(__tstate);
8029 if (PyErr_Occurred()) SWIG_fail;
8030 }
8031 {
8032 wxRect * resultptr;
8033 resultptr = new wxRect((wxRect &)(result));
8034 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
8035 }
8036 return resultobj;
8037 fail:
8038 return NULL;
8039 }
8040
8041
8042 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
8043 PyObject *resultobj;
8044 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8045 bool result;
8046 PyObject * obj0 = 0 ;
8047 char *kwnames[] = {
8048 (char *) "self", NULL
8049 };
8050
8051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
8052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8053 if (SWIG_arg_fail(1)) SWIG_fail;
8054 {
8055 PyThreadState* __tstate = wxPyBeginAllowThreads();
8056 result = (bool)(arg1)->HaveRects();
8057
8058 wxPyEndAllowThreads(__tstate);
8059 if (PyErr_Occurred()) SWIG_fail;
8060 }
8061 {
8062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8063 }
8064 return resultobj;
8065 fail:
8066 return NULL;
8067 }
8068
8069
8070 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
8071 PyObject *resultobj;
8072 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8073 PyObject * obj0 = 0 ;
8074 char *kwnames[] = {
8075 (char *) "self", NULL
8076 };
8077
8078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
8079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8080 if (SWIG_arg_fail(1)) SWIG_fail;
8081 {
8082 PyThreadState* __tstate = wxPyBeginAllowThreads();
8083 (arg1)->Reset();
8084
8085 wxPyEndAllowThreads(__tstate);
8086 if (PyErr_Occurred()) SWIG_fail;
8087 }
8088 Py_INCREF(Py_None); resultobj = Py_None;
8089 return resultobj;
8090 fail:
8091 return NULL;
8092 }
8093
8094
8095 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
8096 PyObject *resultobj;
8097 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8098 PyObject * obj0 = 0 ;
8099 char *kwnames[] = {
8100 (char *) "self", NULL
8101 };
8102
8103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
8104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8105 if (SWIG_arg_fail(1)) SWIG_fail;
8106 {
8107 PyThreadState* __tstate = wxPyBeginAllowThreads();
8108 wxRegionIterator_Next(arg1);
8109
8110 wxPyEndAllowThreads(__tstate);
8111 if (PyErr_Occurred()) SWIG_fail;
8112 }
8113 Py_INCREF(Py_None); resultobj = Py_None;
8114 return resultobj;
8115 fail:
8116 return NULL;
8117 }
8118
8119
8120 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
8121 PyObject *resultobj;
8122 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8123 bool result;
8124 PyObject * obj0 = 0 ;
8125 char *kwnames[] = {
8126 (char *) "self", NULL
8127 };
8128
8129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
8130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8131 if (SWIG_arg_fail(1)) SWIG_fail;
8132 {
8133 PyThreadState* __tstate = wxPyBeginAllowThreads();
8134 result = (bool)wxRegionIterator___nonzero__(arg1);
8135
8136 wxPyEndAllowThreads(__tstate);
8137 if (PyErr_Occurred()) SWIG_fail;
8138 }
8139 {
8140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8141 }
8142 return resultobj;
8143 fail:
8144 return NULL;
8145 }
8146
8147
8148 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
8149 PyObject *obj;
8150 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8151 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
8152 Py_INCREF(obj);
8153 return Py_BuildValue((char *)"");
8154 }
8155 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8156 PyObject *resultobj;
8157 wxNativeFontInfo *result;
8158 char *kwnames[] = {
8159 NULL
8160 };
8161
8162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
8163 {
8164 PyThreadState* __tstate = wxPyBeginAllowThreads();
8165 result = (wxNativeFontInfo *)new wxNativeFontInfo();
8166
8167 wxPyEndAllowThreads(__tstate);
8168 if (PyErr_Occurred()) SWIG_fail;
8169 }
8170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
8171 return resultobj;
8172 fail:
8173 return NULL;
8174 }
8175
8176
8177 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8178 PyObject *resultobj;
8179 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8180 PyObject * obj0 = 0 ;
8181 char *kwnames[] = {
8182 (char *) "self", NULL
8183 };
8184
8185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
8186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8187 if (SWIG_arg_fail(1)) SWIG_fail;
8188 {
8189 PyThreadState* __tstate = wxPyBeginAllowThreads();
8190 delete arg1;
8191
8192 wxPyEndAllowThreads(__tstate);
8193 if (PyErr_Occurred()) SWIG_fail;
8194 }
8195 Py_INCREF(Py_None); resultobj = Py_None;
8196 return resultobj;
8197 fail:
8198 return NULL;
8199 }
8200
8201
8202 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
8203 PyObject *resultobj;
8204 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8205 PyObject * obj0 = 0 ;
8206 char *kwnames[] = {
8207 (char *) "self", NULL
8208 };
8209
8210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
8211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8212 if (SWIG_arg_fail(1)) SWIG_fail;
8213 {
8214 PyThreadState* __tstate = wxPyBeginAllowThreads();
8215 (arg1)->Init();
8216
8217 wxPyEndAllowThreads(__tstate);
8218 if (PyErr_Occurred()) SWIG_fail;
8219 }
8220 Py_INCREF(Py_None); resultobj = Py_None;
8221 return resultobj;
8222 fail:
8223 return NULL;
8224 }
8225
8226
8227 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
8228 PyObject *resultobj;
8229 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8230 wxFont *arg2 = 0 ;
8231 PyObject * obj0 = 0 ;
8232 PyObject * obj1 = 0 ;
8233 char *kwnames[] = {
8234 (char *) "self",(char *) "font", NULL
8235 };
8236
8237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
8238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8239 if (SWIG_arg_fail(1)) SWIG_fail;
8240 {
8241 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
8242 if (SWIG_arg_fail(2)) SWIG_fail;
8243 if (arg2 == NULL) {
8244 SWIG_null_ref("wxFont");
8245 }
8246 if (SWIG_arg_fail(2)) SWIG_fail;
8247 }
8248 {
8249 PyThreadState* __tstate = wxPyBeginAllowThreads();
8250 (arg1)->InitFromFont((wxFont const &)*arg2);
8251
8252 wxPyEndAllowThreads(__tstate);
8253 if (PyErr_Occurred()) SWIG_fail;
8254 }
8255 Py_INCREF(Py_None); resultobj = Py_None;
8256 return resultobj;
8257 fail:
8258 return NULL;
8259 }
8260
8261
8262 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
8263 PyObject *resultobj;
8264 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8265 int result;
8266 PyObject * obj0 = 0 ;
8267 char *kwnames[] = {
8268 (char *) "self", NULL
8269 };
8270
8271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
8272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8273 if (SWIG_arg_fail(1)) SWIG_fail;
8274 {
8275 PyThreadState* __tstate = wxPyBeginAllowThreads();
8276 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
8277
8278 wxPyEndAllowThreads(__tstate);
8279 if (PyErr_Occurred()) SWIG_fail;
8280 }
8281 {
8282 resultobj = SWIG_From_int((int)(result));
8283 }
8284 return resultobj;
8285 fail:
8286 return NULL;
8287 }
8288
8289
8290 static PyObject *_wrap_NativeFontInfo_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
8291 PyObject *resultobj;
8292 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8293 wxSize result;
8294 PyObject * obj0 = 0 ;
8295 char *kwnames[] = {
8296 (char *) "self", NULL
8297 };
8298
8299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPixelSize",kwnames,&obj0)) goto fail;
8300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8301 if (SWIG_arg_fail(1)) SWIG_fail;
8302 {
8303 PyThreadState* __tstate = wxPyBeginAllowThreads();
8304 result = ((wxNativeFontInfo const *)arg1)->GetPixelSize();
8305
8306 wxPyEndAllowThreads(__tstate);
8307 if (PyErr_Occurred()) SWIG_fail;
8308 }
8309 {
8310 wxSize * resultptr;
8311 resultptr = new wxSize((wxSize &)(result));
8312 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
8313 }
8314 return resultobj;
8315 fail:
8316 return NULL;
8317 }
8318
8319
8320 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
8321 PyObject *resultobj;
8322 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8323 wxFontStyle result;
8324 PyObject * obj0 = 0 ;
8325 char *kwnames[] = {
8326 (char *) "self", NULL
8327 };
8328
8329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
8330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8331 if (SWIG_arg_fail(1)) SWIG_fail;
8332 {
8333 PyThreadState* __tstate = wxPyBeginAllowThreads();
8334 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
8335
8336 wxPyEndAllowThreads(__tstate);
8337 if (PyErr_Occurred()) SWIG_fail;
8338 }
8339 resultobj = SWIG_From_int((result));
8340 return resultobj;
8341 fail:
8342 return NULL;
8343 }
8344
8345
8346 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
8347 PyObject *resultobj;
8348 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8349 wxFontWeight result;
8350 PyObject * obj0 = 0 ;
8351 char *kwnames[] = {
8352 (char *) "self", NULL
8353 };
8354
8355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
8356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8357 if (SWIG_arg_fail(1)) SWIG_fail;
8358 {
8359 PyThreadState* __tstate = wxPyBeginAllowThreads();
8360 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
8361
8362 wxPyEndAllowThreads(__tstate);
8363 if (PyErr_Occurred()) SWIG_fail;
8364 }
8365 resultobj = SWIG_From_int((result));
8366 return resultobj;
8367 fail:
8368 return NULL;
8369 }
8370
8371
8372 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8373 PyObject *resultobj;
8374 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8375 bool result;
8376 PyObject * obj0 = 0 ;
8377 char *kwnames[] = {
8378 (char *) "self", NULL
8379 };
8380
8381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
8382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8383 if (SWIG_arg_fail(1)) SWIG_fail;
8384 {
8385 PyThreadState* __tstate = wxPyBeginAllowThreads();
8386 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
8387
8388 wxPyEndAllowThreads(__tstate);
8389 if (PyErr_Occurred()) SWIG_fail;
8390 }
8391 {
8392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8393 }
8394 return resultobj;
8395 fail:
8396 return NULL;
8397 }
8398
8399
8400 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8401 PyObject *resultobj;
8402 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8403 wxString result;
8404 PyObject * obj0 = 0 ;
8405 char *kwnames[] = {
8406 (char *) "self", NULL
8407 };
8408
8409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
8410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8411 if (SWIG_arg_fail(1)) SWIG_fail;
8412 {
8413 PyThreadState* __tstate = wxPyBeginAllowThreads();
8414 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
8415
8416 wxPyEndAllowThreads(__tstate);
8417 if (PyErr_Occurred()) SWIG_fail;
8418 }
8419 {
8420 #if wxUSE_UNICODE
8421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8422 #else
8423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8424 #endif
8425 }
8426 return resultobj;
8427 fail:
8428 return NULL;
8429 }
8430
8431
8432 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8433 PyObject *resultobj;
8434 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8435 wxFontFamily result;
8436 PyObject * obj0 = 0 ;
8437 char *kwnames[] = {
8438 (char *) "self", NULL
8439 };
8440
8441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
8442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8443 if (SWIG_arg_fail(1)) SWIG_fail;
8444 {
8445 PyThreadState* __tstate = wxPyBeginAllowThreads();
8446 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
8447
8448 wxPyEndAllowThreads(__tstate);
8449 if (PyErr_Occurred()) SWIG_fail;
8450 }
8451 resultobj = SWIG_From_int((result));
8452 return resultobj;
8453 fail:
8454 return NULL;
8455 }
8456
8457
8458 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8459 PyObject *resultobj;
8460 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8461 wxFontEncoding result;
8462 PyObject * obj0 = 0 ;
8463 char *kwnames[] = {
8464 (char *) "self", NULL
8465 };
8466
8467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
8468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8469 if (SWIG_arg_fail(1)) SWIG_fail;
8470 {
8471 PyThreadState* __tstate = wxPyBeginAllowThreads();
8472 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
8473
8474 wxPyEndAllowThreads(__tstate);
8475 if (PyErr_Occurred()) SWIG_fail;
8476 }
8477 resultobj = SWIG_From_int((result));
8478 return resultobj;
8479 fail:
8480 return NULL;
8481 }
8482
8483
8484 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
8485 PyObject *resultobj;
8486 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8487 int arg2 ;
8488 PyObject * obj0 = 0 ;
8489 PyObject * obj1 = 0 ;
8490 char *kwnames[] = {
8491 (char *) "self",(char *) "pointsize", NULL
8492 };
8493
8494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
8495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8496 if (SWIG_arg_fail(1)) SWIG_fail;
8497 {
8498 arg2 = (int)(SWIG_As_int(obj1));
8499 if (SWIG_arg_fail(2)) SWIG_fail;
8500 }
8501 {
8502 PyThreadState* __tstate = wxPyBeginAllowThreads();
8503 (arg1)->SetPointSize(arg2);
8504
8505 wxPyEndAllowThreads(__tstate);
8506 if (PyErr_Occurred()) SWIG_fail;
8507 }
8508 Py_INCREF(Py_None); resultobj = Py_None;
8509 return resultobj;
8510 fail:
8511 return NULL;
8512 }
8513
8514
8515 static PyObject *_wrap_NativeFontInfo_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
8516 PyObject *resultobj;
8517 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8518 wxSize *arg2 = 0 ;
8519 wxSize temp2 ;
8520 PyObject * obj0 = 0 ;
8521 PyObject * obj1 = 0 ;
8522 char *kwnames[] = {
8523 (char *) "self",(char *) "pixelSize", NULL
8524 };
8525
8526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
8527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8528 if (SWIG_arg_fail(1)) SWIG_fail;
8529 {
8530 arg2 = &temp2;
8531 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8532 }
8533 {
8534 PyThreadState* __tstate = wxPyBeginAllowThreads();
8535 (arg1)->SetPixelSize((wxSize const &)*arg2);
8536
8537 wxPyEndAllowThreads(__tstate);
8538 if (PyErr_Occurred()) SWIG_fail;
8539 }
8540 Py_INCREF(Py_None); resultobj = Py_None;
8541 return resultobj;
8542 fail:
8543 return NULL;
8544 }
8545
8546
8547 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
8548 PyObject *resultobj;
8549 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8550 wxFontStyle arg2 ;
8551 PyObject * obj0 = 0 ;
8552 PyObject * obj1 = 0 ;
8553 char *kwnames[] = {
8554 (char *) "self",(char *) "style", NULL
8555 };
8556
8557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
8558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8559 if (SWIG_arg_fail(1)) SWIG_fail;
8560 {
8561 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
8562 if (SWIG_arg_fail(2)) SWIG_fail;
8563 }
8564 {
8565 PyThreadState* __tstate = wxPyBeginAllowThreads();
8566 (arg1)->SetStyle((wxFontStyle )arg2);
8567
8568 wxPyEndAllowThreads(__tstate);
8569 if (PyErr_Occurred()) SWIG_fail;
8570 }
8571 Py_INCREF(Py_None); resultobj = Py_None;
8572 return resultobj;
8573 fail:
8574 return NULL;
8575 }
8576
8577
8578 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
8579 PyObject *resultobj;
8580 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8581 wxFontWeight arg2 ;
8582 PyObject * obj0 = 0 ;
8583 PyObject * obj1 = 0 ;
8584 char *kwnames[] = {
8585 (char *) "self",(char *) "weight", NULL
8586 };
8587
8588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
8589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8590 if (SWIG_arg_fail(1)) SWIG_fail;
8591 {
8592 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
8593 if (SWIG_arg_fail(2)) SWIG_fail;
8594 }
8595 {
8596 PyThreadState* __tstate = wxPyBeginAllowThreads();
8597 (arg1)->SetWeight((wxFontWeight )arg2);
8598
8599 wxPyEndAllowThreads(__tstate);
8600 if (PyErr_Occurred()) SWIG_fail;
8601 }
8602 Py_INCREF(Py_None); resultobj = Py_None;
8603 return resultobj;
8604 fail:
8605 return NULL;
8606 }
8607
8608
8609 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8610 PyObject *resultobj;
8611 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8612 bool arg2 ;
8613 PyObject * obj0 = 0 ;
8614 PyObject * obj1 = 0 ;
8615 char *kwnames[] = {
8616 (char *) "self",(char *) "underlined", NULL
8617 };
8618
8619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
8620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8621 if (SWIG_arg_fail(1)) SWIG_fail;
8622 {
8623 arg2 = (bool)(SWIG_As_bool(obj1));
8624 if (SWIG_arg_fail(2)) SWIG_fail;
8625 }
8626 {
8627 PyThreadState* __tstate = wxPyBeginAllowThreads();
8628 (arg1)->SetUnderlined(arg2);
8629
8630 wxPyEndAllowThreads(__tstate);
8631 if (PyErr_Occurred()) SWIG_fail;
8632 }
8633 Py_INCREF(Py_None); resultobj = Py_None;
8634 return resultobj;
8635 fail:
8636 return NULL;
8637 }
8638
8639
8640 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8641 PyObject *resultobj;
8642 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8643 wxString arg2 ;
8644 PyObject * obj0 = 0 ;
8645 PyObject * obj1 = 0 ;
8646 char *kwnames[] = {
8647 (char *) "self",(char *) "facename", NULL
8648 };
8649
8650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
8651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8652 if (SWIG_arg_fail(1)) SWIG_fail;
8653 {
8654 wxString* sptr = wxString_in_helper(obj1);
8655 if (sptr == NULL) SWIG_fail;
8656 arg2 = *sptr;
8657 delete sptr;
8658 }
8659 {
8660 PyThreadState* __tstate = wxPyBeginAllowThreads();
8661 (arg1)->SetFaceName(arg2);
8662
8663 wxPyEndAllowThreads(__tstate);
8664 if (PyErr_Occurred()) SWIG_fail;
8665 }
8666 Py_INCREF(Py_None); resultobj = Py_None;
8667 return resultobj;
8668 fail:
8669 return NULL;
8670 }
8671
8672
8673 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8674 PyObject *resultobj;
8675 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8676 wxFontFamily arg2 ;
8677 PyObject * obj0 = 0 ;
8678 PyObject * obj1 = 0 ;
8679 char *kwnames[] = {
8680 (char *) "self",(char *) "family", NULL
8681 };
8682
8683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8685 if (SWIG_arg_fail(1)) SWIG_fail;
8686 {
8687 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8688 if (SWIG_arg_fail(2)) SWIG_fail;
8689 }
8690 {
8691 PyThreadState* __tstate = wxPyBeginAllowThreads();
8692 (arg1)->SetFamily((wxFontFamily )arg2);
8693
8694 wxPyEndAllowThreads(__tstate);
8695 if (PyErr_Occurred()) SWIG_fail;
8696 }
8697 Py_INCREF(Py_None); resultobj = Py_None;
8698 return resultobj;
8699 fail:
8700 return NULL;
8701 }
8702
8703
8704 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8705 PyObject *resultobj;
8706 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8707 wxFontEncoding arg2 ;
8708 PyObject * obj0 = 0 ;
8709 PyObject * obj1 = 0 ;
8710 char *kwnames[] = {
8711 (char *) "self",(char *) "encoding", NULL
8712 };
8713
8714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8716 if (SWIG_arg_fail(1)) SWIG_fail;
8717 {
8718 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8719 if (SWIG_arg_fail(2)) SWIG_fail;
8720 }
8721 {
8722 PyThreadState* __tstate = wxPyBeginAllowThreads();
8723 (arg1)->SetEncoding((wxFontEncoding )arg2);
8724
8725 wxPyEndAllowThreads(__tstate);
8726 if (PyErr_Occurred()) SWIG_fail;
8727 }
8728 Py_INCREF(Py_None); resultobj = Py_None;
8729 return resultobj;
8730 fail:
8731 return NULL;
8732 }
8733
8734
8735 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8736 PyObject *resultobj;
8737 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8738 wxString *arg2 = 0 ;
8739 bool result;
8740 bool temp2 = false ;
8741 PyObject * obj0 = 0 ;
8742 PyObject * obj1 = 0 ;
8743 char *kwnames[] = {
8744 (char *) "self",(char *) "s", NULL
8745 };
8746
8747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8749 if (SWIG_arg_fail(1)) SWIG_fail;
8750 {
8751 arg2 = wxString_in_helper(obj1);
8752 if (arg2 == NULL) SWIG_fail;
8753 temp2 = true;
8754 }
8755 {
8756 PyThreadState* __tstate = wxPyBeginAllowThreads();
8757 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8758
8759 wxPyEndAllowThreads(__tstate);
8760 if (PyErr_Occurred()) SWIG_fail;
8761 }
8762 {
8763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8764 }
8765 {
8766 if (temp2)
8767 delete arg2;
8768 }
8769 return resultobj;
8770 fail:
8771 {
8772 if (temp2)
8773 delete arg2;
8774 }
8775 return NULL;
8776 }
8777
8778
8779 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8780 PyObject *resultobj;
8781 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8782 wxString result;
8783 PyObject * obj0 = 0 ;
8784 char *kwnames[] = {
8785 (char *) "self", NULL
8786 };
8787
8788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8790 if (SWIG_arg_fail(1)) SWIG_fail;
8791 {
8792 PyThreadState* __tstate = wxPyBeginAllowThreads();
8793 result = ((wxNativeFontInfo const *)arg1)->ToString();
8794
8795 wxPyEndAllowThreads(__tstate);
8796 if (PyErr_Occurred()) SWIG_fail;
8797 }
8798 {
8799 #if wxUSE_UNICODE
8800 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8801 #else
8802 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8803 #endif
8804 }
8805 return resultobj;
8806 fail:
8807 return NULL;
8808 }
8809
8810
8811 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8812 PyObject *resultobj;
8813 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8814 wxString result;
8815 PyObject * obj0 = 0 ;
8816 char *kwnames[] = {
8817 (char *) "self", NULL
8818 };
8819
8820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8822 if (SWIG_arg_fail(1)) SWIG_fail;
8823 {
8824 PyThreadState* __tstate = wxPyBeginAllowThreads();
8825 result = wxNativeFontInfo___str__(arg1);
8826
8827 wxPyEndAllowThreads(__tstate);
8828 if (PyErr_Occurred()) SWIG_fail;
8829 }
8830 {
8831 #if wxUSE_UNICODE
8832 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8833 #else
8834 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8835 #endif
8836 }
8837 return resultobj;
8838 fail:
8839 return NULL;
8840 }
8841
8842
8843 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8844 PyObject *resultobj;
8845 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8846 wxString *arg2 = 0 ;
8847 bool result;
8848 bool temp2 = false ;
8849 PyObject * obj0 = 0 ;
8850 PyObject * obj1 = 0 ;
8851 char *kwnames[] = {
8852 (char *) "self",(char *) "s", NULL
8853 };
8854
8855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8857 if (SWIG_arg_fail(1)) SWIG_fail;
8858 {
8859 arg2 = wxString_in_helper(obj1);
8860 if (arg2 == NULL) SWIG_fail;
8861 temp2 = true;
8862 }
8863 {
8864 PyThreadState* __tstate = wxPyBeginAllowThreads();
8865 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8866
8867 wxPyEndAllowThreads(__tstate);
8868 if (PyErr_Occurred()) SWIG_fail;
8869 }
8870 {
8871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8872 }
8873 {
8874 if (temp2)
8875 delete arg2;
8876 }
8877 return resultobj;
8878 fail:
8879 {
8880 if (temp2)
8881 delete arg2;
8882 }
8883 return NULL;
8884 }
8885
8886
8887 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8888 PyObject *resultobj;
8889 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8890 wxString result;
8891 PyObject * obj0 = 0 ;
8892 char *kwnames[] = {
8893 (char *) "self", NULL
8894 };
8895
8896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8898 if (SWIG_arg_fail(1)) SWIG_fail;
8899 {
8900 PyThreadState* __tstate = wxPyBeginAllowThreads();
8901 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8902
8903 wxPyEndAllowThreads(__tstate);
8904 if (PyErr_Occurred()) SWIG_fail;
8905 }
8906 {
8907 #if wxUSE_UNICODE
8908 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8909 #else
8910 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8911 #endif
8912 }
8913 return resultobj;
8914 fail:
8915 return NULL;
8916 }
8917
8918
8919 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8920 PyObject *obj;
8921 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8922 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8923 Py_INCREF(obj);
8924 return Py_BuildValue((char *)"");
8925 }
8926 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8927 PyObject *resultobj;
8928 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8929 wxString *arg2 = (wxString *) 0 ;
8930 bool temp2 = false ;
8931 PyObject * obj0 = 0 ;
8932 PyObject * obj1 = 0 ;
8933 char *kwnames[] = {
8934 (char *) "self",(char *) "facename", NULL
8935 };
8936
8937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8939 if (SWIG_arg_fail(1)) SWIG_fail;
8940 {
8941 arg2 = wxString_in_helper(obj1);
8942 if (arg2 == NULL) SWIG_fail;
8943 temp2 = true;
8944 }
8945 if (arg1) (arg1)->facename = *arg2;
8946
8947 Py_INCREF(Py_None); resultobj = Py_None;
8948 {
8949 if (temp2)
8950 delete arg2;
8951 }
8952 return resultobj;
8953 fail:
8954 {
8955 if (temp2)
8956 delete arg2;
8957 }
8958 return NULL;
8959 }
8960
8961
8962 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8963 PyObject *resultobj;
8964 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8965 wxString *result;
8966 PyObject * obj0 = 0 ;
8967 char *kwnames[] = {
8968 (char *) "self", NULL
8969 };
8970
8971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
8972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8973 if (SWIG_arg_fail(1)) SWIG_fail;
8974 result = (wxString *)& ((arg1)->facename);
8975
8976 {
8977 #if wxUSE_UNICODE
8978 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8979 #else
8980 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8981 #endif
8982 }
8983 return resultobj;
8984 fail:
8985 return NULL;
8986 }
8987
8988
8989 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8990 PyObject *resultobj;
8991 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8992 wxFontEncoding arg2 ;
8993 PyObject * obj0 = 0 ;
8994 PyObject * obj1 = 0 ;
8995 char *kwnames[] = {
8996 (char *) "self",(char *) "encoding", NULL
8997 };
8998
8999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
9000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9001 if (SWIG_arg_fail(1)) SWIG_fail;
9002 {
9003 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9004 if (SWIG_arg_fail(2)) SWIG_fail;
9005 }
9006 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
9007
9008 Py_INCREF(Py_None); resultobj = Py_None;
9009 return resultobj;
9010 fail:
9011 return NULL;
9012 }
9013
9014
9015 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
9016 PyObject *resultobj;
9017 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9018 wxFontEncoding result;
9019 PyObject * obj0 = 0 ;
9020 char *kwnames[] = {
9021 (char *) "self", NULL
9022 };
9023
9024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
9025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9026 if (SWIG_arg_fail(1)) SWIG_fail;
9027 result = (wxFontEncoding) ((arg1)->encoding);
9028
9029 resultobj = SWIG_From_int((result));
9030 return resultobj;
9031 fail:
9032 return NULL;
9033 }
9034
9035
9036 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9037 PyObject *resultobj;
9038 wxNativeEncodingInfo *result;
9039 char *kwnames[] = {
9040 NULL
9041 };
9042
9043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
9044 {
9045 PyThreadState* __tstate = wxPyBeginAllowThreads();
9046 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
9047
9048 wxPyEndAllowThreads(__tstate);
9049 if (PyErr_Occurred()) SWIG_fail;
9050 }
9051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
9052 return resultobj;
9053 fail:
9054 return NULL;
9055 }
9056
9057
9058 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9059 PyObject *resultobj;
9060 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9061 PyObject * obj0 = 0 ;
9062 char *kwnames[] = {
9063 (char *) "self", NULL
9064 };
9065
9066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
9067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9068 if (SWIG_arg_fail(1)) SWIG_fail;
9069 {
9070 PyThreadState* __tstate = wxPyBeginAllowThreads();
9071 delete arg1;
9072
9073 wxPyEndAllowThreads(__tstate);
9074 if (PyErr_Occurred()) SWIG_fail;
9075 }
9076 Py_INCREF(Py_None); resultobj = Py_None;
9077 return resultobj;
9078 fail:
9079 return NULL;
9080 }
9081
9082
9083 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
9084 PyObject *resultobj;
9085 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9086 wxString *arg2 = 0 ;
9087 bool result;
9088 bool temp2 = false ;
9089 PyObject * obj0 = 0 ;
9090 PyObject * obj1 = 0 ;
9091 char *kwnames[] = {
9092 (char *) "self",(char *) "s", NULL
9093 };
9094
9095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
9096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9097 if (SWIG_arg_fail(1)) SWIG_fail;
9098 {
9099 arg2 = wxString_in_helper(obj1);
9100 if (arg2 == NULL) SWIG_fail;
9101 temp2 = true;
9102 }
9103 {
9104 PyThreadState* __tstate = wxPyBeginAllowThreads();
9105 result = (bool)(arg1)->FromString((wxString const &)*arg2);
9106
9107 wxPyEndAllowThreads(__tstate);
9108 if (PyErr_Occurred()) SWIG_fail;
9109 }
9110 {
9111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9112 }
9113 {
9114 if (temp2)
9115 delete arg2;
9116 }
9117 return resultobj;
9118 fail:
9119 {
9120 if (temp2)
9121 delete arg2;
9122 }
9123 return NULL;
9124 }
9125
9126
9127 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
9128 PyObject *resultobj;
9129 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9130 wxString result;
9131 PyObject * obj0 = 0 ;
9132 char *kwnames[] = {
9133 (char *) "self", NULL
9134 };
9135
9136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
9137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9138 if (SWIG_arg_fail(1)) SWIG_fail;
9139 {
9140 PyThreadState* __tstate = wxPyBeginAllowThreads();
9141 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
9142
9143 wxPyEndAllowThreads(__tstate);
9144 if (PyErr_Occurred()) SWIG_fail;
9145 }
9146 {
9147 #if wxUSE_UNICODE
9148 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9149 #else
9150 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9151 #endif
9152 }
9153 return resultobj;
9154 fail:
9155 return NULL;
9156 }
9157
9158
9159 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
9160 PyObject *obj;
9161 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9162 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
9163 Py_INCREF(obj);
9164 return Py_BuildValue((char *)"");
9165 }
9166 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9167 PyObject *resultobj;
9168 wxFontEncoding arg1 ;
9169 wxNativeEncodingInfo *result;
9170 PyObject * obj0 = 0 ;
9171 char *kwnames[] = {
9172 (char *) "encoding", NULL
9173 };
9174
9175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
9176 {
9177 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9178 if (SWIG_arg_fail(1)) SWIG_fail;
9179 }
9180 {
9181 PyThreadState* __tstate = wxPyBeginAllowThreads();
9182 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
9183
9184 wxPyEndAllowThreads(__tstate);
9185 if (PyErr_Occurred()) SWIG_fail;
9186 }
9187 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
9188 return resultobj;
9189 fail:
9190 return NULL;
9191 }
9192
9193
9194 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9195 PyObject *resultobj;
9196 wxNativeEncodingInfo *arg1 = 0 ;
9197 bool result;
9198 PyObject * obj0 = 0 ;
9199 char *kwnames[] = {
9200 (char *) "info", NULL
9201 };
9202
9203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
9204 {
9205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9206 if (SWIG_arg_fail(1)) SWIG_fail;
9207 if (arg1 == NULL) {
9208 SWIG_null_ref("wxNativeEncodingInfo");
9209 }
9210 if (SWIG_arg_fail(1)) SWIG_fail;
9211 }
9212 {
9213 PyThreadState* __tstate = wxPyBeginAllowThreads();
9214 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
9215
9216 wxPyEndAllowThreads(__tstate);
9217 if (PyErr_Occurred()) SWIG_fail;
9218 }
9219 {
9220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9221 }
9222 return resultobj;
9223 fail:
9224 return NULL;
9225 }
9226
9227
9228 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
9229 PyObject *resultobj;
9230 wxFontMapper *result;
9231 char *kwnames[] = {
9232 NULL
9233 };
9234
9235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
9236 {
9237 PyThreadState* __tstate = wxPyBeginAllowThreads();
9238 result = (wxFontMapper *)new wxFontMapper();
9239
9240 wxPyEndAllowThreads(__tstate);
9241 if (PyErr_Occurred()) SWIG_fail;
9242 }
9243 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
9244 return resultobj;
9245 fail:
9246 return NULL;
9247 }
9248
9249
9250 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
9251 PyObject *resultobj;
9252 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9253 PyObject * obj0 = 0 ;
9254 char *kwnames[] = {
9255 (char *) "self", NULL
9256 };
9257
9258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
9259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9260 if (SWIG_arg_fail(1)) SWIG_fail;
9261 {
9262 PyThreadState* __tstate = wxPyBeginAllowThreads();
9263 delete arg1;
9264
9265 wxPyEndAllowThreads(__tstate);
9266 if (PyErr_Occurred()) SWIG_fail;
9267 }
9268 Py_INCREF(Py_None); resultobj = Py_None;
9269 return resultobj;
9270 fail:
9271 return NULL;
9272 }
9273
9274
9275 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
9276 PyObject *resultobj;
9277 wxFontMapper *result;
9278 char *kwnames[] = {
9279 NULL
9280 };
9281
9282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
9283 {
9284 PyThreadState* __tstate = wxPyBeginAllowThreads();
9285 result = (wxFontMapper *)wxFontMapper::Get();
9286
9287 wxPyEndAllowThreads(__tstate);
9288 if (PyErr_Occurred()) SWIG_fail;
9289 }
9290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
9291 return resultobj;
9292 fail:
9293 return NULL;
9294 }
9295
9296
9297 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
9298 PyObject *resultobj;
9299 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9300 wxFontMapper *result;
9301 PyObject * obj0 = 0 ;
9302 char *kwnames[] = {
9303 (char *) "mapper", NULL
9304 };
9305
9306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
9307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9308 if (SWIG_arg_fail(1)) SWIG_fail;
9309 {
9310 PyThreadState* __tstate = wxPyBeginAllowThreads();
9311 result = (wxFontMapper *)wxFontMapper::Set(arg1);
9312
9313 wxPyEndAllowThreads(__tstate);
9314 if (PyErr_Occurred()) SWIG_fail;
9315 }
9316 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
9317 return resultobj;
9318 fail:
9319 return NULL;
9320 }
9321
9322
9323 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9324 PyObject *resultobj;
9325 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9326 wxString *arg2 = 0 ;
9327 bool arg3 = (bool) true ;
9328 wxFontEncoding result;
9329 bool temp2 = false ;
9330 PyObject * obj0 = 0 ;
9331 PyObject * obj1 = 0 ;
9332 PyObject * obj2 = 0 ;
9333 char *kwnames[] = {
9334 (char *) "self",(char *) "charset",(char *) "interactive", NULL
9335 };
9336
9337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
9338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9339 if (SWIG_arg_fail(1)) SWIG_fail;
9340 {
9341 arg2 = wxString_in_helper(obj1);
9342 if (arg2 == NULL) SWIG_fail;
9343 temp2 = true;
9344 }
9345 if (obj2) {
9346 {
9347 arg3 = (bool)(SWIG_As_bool(obj2));
9348 if (SWIG_arg_fail(3)) SWIG_fail;
9349 }
9350 }
9351 {
9352 PyThreadState* __tstate = wxPyBeginAllowThreads();
9353 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
9354
9355 wxPyEndAllowThreads(__tstate);
9356 if (PyErr_Occurred()) SWIG_fail;
9357 }
9358 resultobj = SWIG_From_int((result));
9359 {
9360 if (temp2)
9361 delete arg2;
9362 }
9363 return resultobj;
9364 fail:
9365 {
9366 if (temp2)
9367 delete arg2;
9368 }
9369 return NULL;
9370 }
9371
9372
9373 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
9374 PyObject *resultobj;
9375 size_t result;
9376 char *kwnames[] = {
9377 NULL
9378 };
9379
9380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
9381 {
9382 PyThreadState* __tstate = wxPyBeginAllowThreads();
9383 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
9384
9385 wxPyEndAllowThreads(__tstate);
9386 if (PyErr_Occurred()) SWIG_fail;
9387 }
9388 {
9389 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9390 }
9391 return resultobj;
9392 fail:
9393 return NULL;
9394 }
9395
9396
9397 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9398 PyObject *resultobj;
9399 size_t arg1 ;
9400 wxFontEncoding result;
9401 PyObject * obj0 = 0 ;
9402 char *kwnames[] = {
9403 (char *) "n", NULL
9404 };
9405
9406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
9407 {
9408 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
9409 if (SWIG_arg_fail(1)) SWIG_fail;
9410 }
9411 {
9412 PyThreadState* __tstate = wxPyBeginAllowThreads();
9413 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
9414
9415 wxPyEndAllowThreads(__tstate);
9416 if (PyErr_Occurred()) SWIG_fail;
9417 }
9418 resultobj = SWIG_From_int((result));
9419 return resultobj;
9420 fail:
9421 return NULL;
9422 }
9423
9424
9425 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
9426 PyObject *resultobj;
9427 wxFontEncoding arg1 ;
9428 wxString result;
9429 PyObject * obj0 = 0 ;
9430 char *kwnames[] = {
9431 (char *) "encoding", NULL
9432 };
9433
9434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
9435 {
9436 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9437 if (SWIG_arg_fail(1)) SWIG_fail;
9438 }
9439 {
9440 PyThreadState* __tstate = wxPyBeginAllowThreads();
9441 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
9442
9443 wxPyEndAllowThreads(__tstate);
9444 if (PyErr_Occurred()) SWIG_fail;
9445 }
9446 {
9447 #if wxUSE_UNICODE
9448 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9449 #else
9450 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9451 #endif
9452 }
9453 return resultobj;
9454 fail:
9455 return NULL;
9456 }
9457
9458
9459 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
9460 PyObject *resultobj;
9461 wxFontEncoding arg1 ;
9462 wxString result;
9463 PyObject * obj0 = 0 ;
9464 char *kwnames[] = {
9465 (char *) "encoding", NULL
9466 };
9467
9468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
9469 {
9470 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9471 if (SWIG_arg_fail(1)) SWIG_fail;
9472 }
9473 {
9474 PyThreadState* __tstate = wxPyBeginAllowThreads();
9475 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
9476
9477 wxPyEndAllowThreads(__tstate);
9478 if (PyErr_Occurred()) SWIG_fail;
9479 }
9480 {
9481 #if wxUSE_UNICODE
9482 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9483 #else
9484 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9485 #endif
9486 }
9487 return resultobj;
9488 fail:
9489 return NULL;
9490 }
9491
9492
9493 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
9494 PyObject *resultobj;
9495 wxString *arg1 = 0 ;
9496 wxFontEncoding result;
9497 bool temp1 = false ;
9498 PyObject * obj0 = 0 ;
9499 char *kwnames[] = {
9500 (char *) "name", NULL
9501 };
9502
9503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
9504 {
9505 arg1 = wxString_in_helper(obj0);
9506 if (arg1 == NULL) SWIG_fail;
9507 temp1 = true;
9508 }
9509 {
9510 PyThreadState* __tstate = wxPyBeginAllowThreads();
9511 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
9512
9513 wxPyEndAllowThreads(__tstate);
9514 if (PyErr_Occurred()) SWIG_fail;
9515 }
9516 resultobj = SWIG_From_int((result));
9517 {
9518 if (temp1)
9519 delete arg1;
9520 }
9521 return resultobj;
9522 fail:
9523 {
9524 if (temp1)
9525 delete arg1;
9526 }
9527 return NULL;
9528 }
9529
9530
9531 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
9532 PyObject *resultobj;
9533 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9534 wxConfigBase *arg2 = (wxConfigBase *) 0 ;
9535 PyObject * obj0 = 0 ;
9536 PyObject * obj1 = 0 ;
9537 char *kwnames[] = {
9538 (char *) "self",(char *) "config", NULL
9539 };
9540
9541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
9542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9543 if (SWIG_arg_fail(1)) SWIG_fail;
9544 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
9545 if (SWIG_arg_fail(2)) SWIG_fail;
9546 {
9547 PyThreadState* __tstate = wxPyBeginAllowThreads();
9548 (arg1)->SetConfig(arg2);
9549
9550 wxPyEndAllowThreads(__tstate);
9551 if (PyErr_Occurred()) SWIG_fail;
9552 }
9553 Py_INCREF(Py_None); resultobj = Py_None;
9554 return resultobj;
9555 fail:
9556 return NULL;
9557 }
9558
9559
9560 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
9561 PyObject *resultobj;
9562 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9563 wxString *arg2 = 0 ;
9564 bool temp2 = false ;
9565 PyObject * obj0 = 0 ;
9566 PyObject * obj1 = 0 ;
9567 char *kwnames[] = {
9568 (char *) "self",(char *) "prefix", NULL
9569 };
9570
9571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
9572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9573 if (SWIG_arg_fail(1)) SWIG_fail;
9574 {
9575 arg2 = wxString_in_helper(obj1);
9576 if (arg2 == NULL) SWIG_fail;
9577 temp2 = true;
9578 }
9579 {
9580 PyThreadState* __tstate = wxPyBeginAllowThreads();
9581 (arg1)->SetConfigPath((wxString const &)*arg2);
9582
9583 wxPyEndAllowThreads(__tstate);
9584 if (PyErr_Occurred()) SWIG_fail;
9585 }
9586 Py_INCREF(Py_None); resultobj = Py_None;
9587 {
9588 if (temp2)
9589 delete arg2;
9590 }
9591 return resultobj;
9592 fail:
9593 {
9594 if (temp2)
9595 delete arg2;
9596 }
9597 return NULL;
9598 }
9599
9600
9601 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
9602 PyObject *resultobj;
9603 wxString result;
9604 char *kwnames[] = {
9605 NULL
9606 };
9607
9608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
9609 {
9610 PyThreadState* __tstate = wxPyBeginAllowThreads();
9611 result = wxFontMapper::GetDefaultConfigPath();
9612
9613 wxPyEndAllowThreads(__tstate);
9614 if (PyErr_Occurred()) SWIG_fail;
9615 }
9616 {
9617 #if wxUSE_UNICODE
9618 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9619 #else
9620 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9621 #endif
9622 }
9623 return resultobj;
9624 fail:
9625 return NULL;
9626 }
9627
9628
9629 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9630 PyObject *resultobj;
9631 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9632 wxFontEncoding arg2 ;
9633 wxString const &arg3_defvalue = wxPyEmptyString ;
9634 wxString *arg3 = (wxString *) &arg3_defvalue ;
9635 bool arg4 = (bool) true ;
9636 PyObject *result;
9637 bool temp3 = false ;
9638 PyObject * obj0 = 0 ;
9639 PyObject * obj1 = 0 ;
9640 PyObject * obj2 = 0 ;
9641 PyObject * obj3 = 0 ;
9642 char *kwnames[] = {
9643 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
9644 };
9645
9646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9648 if (SWIG_arg_fail(1)) SWIG_fail;
9649 {
9650 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9651 if (SWIG_arg_fail(2)) SWIG_fail;
9652 }
9653 if (obj2) {
9654 {
9655 arg3 = wxString_in_helper(obj2);
9656 if (arg3 == NULL) SWIG_fail;
9657 temp3 = true;
9658 }
9659 }
9660 if (obj3) {
9661 {
9662 arg4 = (bool)(SWIG_As_bool(obj3));
9663 if (SWIG_arg_fail(4)) SWIG_fail;
9664 }
9665 }
9666 {
9667 PyThreadState* __tstate = wxPyBeginAllowThreads();
9668 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9669
9670 wxPyEndAllowThreads(__tstate);
9671 if (PyErr_Occurred()) SWIG_fail;
9672 }
9673 resultobj = result;
9674 {
9675 if (temp3)
9676 delete arg3;
9677 }
9678 return resultobj;
9679 fail:
9680 {
9681 if (temp3)
9682 delete arg3;
9683 }
9684 return NULL;
9685 }
9686
9687
9688 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9689 PyObject *resultobj;
9690 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9691 wxFontEncoding arg2 ;
9692 wxString const &arg3_defvalue = wxPyEmptyString ;
9693 wxString *arg3 = (wxString *) &arg3_defvalue ;
9694 bool result;
9695 bool temp3 = false ;
9696 PyObject * obj0 = 0 ;
9697 PyObject * obj1 = 0 ;
9698 PyObject * obj2 = 0 ;
9699 char *kwnames[] = {
9700 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9701 };
9702
9703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9705 if (SWIG_arg_fail(1)) SWIG_fail;
9706 {
9707 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9708 if (SWIG_arg_fail(2)) SWIG_fail;
9709 }
9710 if (obj2) {
9711 {
9712 arg3 = wxString_in_helper(obj2);
9713 if (arg3 == NULL) SWIG_fail;
9714 temp3 = true;
9715 }
9716 }
9717 {
9718 PyThreadState* __tstate = wxPyBeginAllowThreads();
9719 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9720
9721 wxPyEndAllowThreads(__tstate);
9722 if (PyErr_Occurred()) SWIG_fail;
9723 }
9724 {
9725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9726 }
9727 {
9728 if (temp3)
9729 delete arg3;
9730 }
9731 return resultobj;
9732 fail:
9733 {
9734 if (temp3)
9735 delete arg3;
9736 }
9737 return NULL;
9738 }
9739
9740
9741 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9742 PyObject *resultobj;
9743 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9744 wxWindow *arg2 = (wxWindow *) 0 ;
9745 PyObject * obj0 = 0 ;
9746 PyObject * obj1 = 0 ;
9747 char *kwnames[] = {
9748 (char *) "self",(char *) "parent", NULL
9749 };
9750
9751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9753 if (SWIG_arg_fail(1)) SWIG_fail;
9754 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9755 if (SWIG_arg_fail(2)) SWIG_fail;
9756 {
9757 PyThreadState* __tstate = wxPyBeginAllowThreads();
9758 (arg1)->SetDialogParent(arg2);
9759
9760 wxPyEndAllowThreads(__tstate);
9761 if (PyErr_Occurred()) SWIG_fail;
9762 }
9763 Py_INCREF(Py_None); resultobj = Py_None;
9764 return resultobj;
9765 fail:
9766 return NULL;
9767 }
9768
9769
9770 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9771 PyObject *resultobj;
9772 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9773 wxString *arg2 = 0 ;
9774 bool temp2 = false ;
9775 PyObject * obj0 = 0 ;
9776 PyObject * obj1 = 0 ;
9777 char *kwnames[] = {
9778 (char *) "self",(char *) "title", NULL
9779 };
9780
9781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9783 if (SWIG_arg_fail(1)) SWIG_fail;
9784 {
9785 arg2 = wxString_in_helper(obj1);
9786 if (arg2 == NULL) SWIG_fail;
9787 temp2 = true;
9788 }
9789 {
9790 PyThreadState* __tstate = wxPyBeginAllowThreads();
9791 (arg1)->SetDialogTitle((wxString const &)*arg2);
9792
9793 wxPyEndAllowThreads(__tstate);
9794 if (PyErr_Occurred()) SWIG_fail;
9795 }
9796 Py_INCREF(Py_None); resultobj = Py_None;
9797 {
9798 if (temp2)
9799 delete arg2;
9800 }
9801 return resultobj;
9802 fail:
9803 {
9804 if (temp2)
9805 delete arg2;
9806 }
9807 return NULL;
9808 }
9809
9810
9811 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9812 PyObject *obj;
9813 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9814 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9815 Py_INCREF(obj);
9816 return Py_BuildValue((char *)"");
9817 }
9818 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9819 PyObject *resultobj;
9820 int arg1 ;
9821 int arg2 ;
9822 int arg3 ;
9823 int arg4 ;
9824 bool arg5 = (bool) false ;
9825 wxString const &arg6_defvalue = wxPyEmptyString ;
9826 wxString *arg6 = (wxString *) &arg6_defvalue ;
9827 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9828 wxFont *result;
9829 bool temp6 = false ;
9830 PyObject * obj0 = 0 ;
9831 PyObject * obj1 = 0 ;
9832 PyObject * obj2 = 0 ;
9833 PyObject * obj3 = 0 ;
9834 PyObject * obj4 = 0 ;
9835 PyObject * obj5 = 0 ;
9836 PyObject * obj6 = 0 ;
9837 char *kwnames[] = {
9838 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9839 };
9840
9841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9842 {
9843 arg1 = (int)(SWIG_As_int(obj0));
9844 if (SWIG_arg_fail(1)) SWIG_fail;
9845 }
9846 {
9847 arg2 = (int)(SWIG_As_int(obj1));
9848 if (SWIG_arg_fail(2)) SWIG_fail;
9849 }
9850 {
9851 arg3 = (int)(SWIG_As_int(obj2));
9852 if (SWIG_arg_fail(3)) SWIG_fail;
9853 }
9854 {
9855 arg4 = (int)(SWIG_As_int(obj3));
9856 if (SWIG_arg_fail(4)) SWIG_fail;
9857 }
9858 if (obj4) {
9859 {
9860 arg5 = (bool)(SWIG_As_bool(obj4));
9861 if (SWIG_arg_fail(5)) SWIG_fail;
9862 }
9863 }
9864 if (obj5) {
9865 {
9866 arg6 = wxString_in_helper(obj5);
9867 if (arg6 == NULL) SWIG_fail;
9868 temp6 = true;
9869 }
9870 }
9871 if (obj6) {
9872 {
9873 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9874 if (SWIG_arg_fail(7)) SWIG_fail;
9875 }
9876 }
9877 {
9878 if (!wxPyCheckForApp()) SWIG_fail;
9879 PyThreadState* __tstate = wxPyBeginAllowThreads();
9880 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9881
9882 wxPyEndAllowThreads(__tstate);
9883 if (PyErr_Occurred()) SWIG_fail;
9884 }
9885 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9886 {
9887 if (temp6)
9888 delete arg6;
9889 }
9890 return resultobj;
9891 fail:
9892 {
9893 if (temp6)
9894 delete arg6;
9895 }
9896 return NULL;
9897 }
9898
9899
9900 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9901 PyObject *resultobj;
9902 wxFont *arg1 = (wxFont *) 0 ;
9903 PyObject * obj0 = 0 ;
9904 char *kwnames[] = {
9905 (char *) "self", NULL
9906 };
9907
9908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9910 if (SWIG_arg_fail(1)) SWIG_fail;
9911 {
9912 PyThreadState* __tstate = wxPyBeginAllowThreads();
9913 delete arg1;
9914
9915 wxPyEndAllowThreads(__tstate);
9916 if (PyErr_Occurred()) SWIG_fail;
9917 }
9918 Py_INCREF(Py_None); resultobj = Py_None;
9919 return resultobj;
9920 fail:
9921 return NULL;
9922 }
9923
9924
9925 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9926 PyObject *resultobj;
9927 wxNativeFontInfo *arg1 = 0 ;
9928 wxFont *result;
9929 PyObject * obj0 = 0 ;
9930 char *kwnames[] = {
9931 (char *) "info", NULL
9932 };
9933
9934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9935 {
9936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9937 if (SWIG_arg_fail(1)) SWIG_fail;
9938 if (arg1 == NULL) {
9939 SWIG_null_ref("wxNativeFontInfo");
9940 }
9941 if (SWIG_arg_fail(1)) SWIG_fail;
9942 }
9943 {
9944 if (!wxPyCheckForApp()) SWIG_fail;
9945 PyThreadState* __tstate = wxPyBeginAllowThreads();
9946 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9947
9948 wxPyEndAllowThreads(__tstate);
9949 if (PyErr_Occurred()) SWIG_fail;
9950 }
9951 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9952 return resultobj;
9953 fail:
9954 return NULL;
9955 }
9956
9957
9958 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9959 PyObject *resultobj;
9960 wxString *arg1 = 0 ;
9961 wxFont *result;
9962 bool temp1 = false ;
9963 PyObject * obj0 = 0 ;
9964 char *kwnames[] = {
9965 (char *) "info", NULL
9966 };
9967
9968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9969 {
9970 arg1 = wxString_in_helper(obj0);
9971 if (arg1 == NULL) SWIG_fail;
9972 temp1 = true;
9973 }
9974 {
9975 if (!wxPyCheckForApp()) SWIG_fail;
9976 PyThreadState* __tstate = wxPyBeginAllowThreads();
9977 result = (wxFont *)new_wxFont((wxString const &)*arg1);
9978
9979 wxPyEndAllowThreads(__tstate);
9980 if (PyErr_Occurred()) SWIG_fail;
9981 }
9982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9983 {
9984 if (temp1)
9985 delete arg1;
9986 }
9987 return resultobj;
9988 fail:
9989 {
9990 if (temp1)
9991 delete arg1;
9992 }
9993 return NULL;
9994 }
9995
9996
9997 static PyObject *_wrap_new_Font2(PyObject *, PyObject *args, PyObject *kwargs) {
9998 PyObject *resultobj;
9999 int arg1 ;
10000 wxFontFamily arg2 ;
10001 int arg3 = (int) wxFONTFLAG_DEFAULT ;
10002 wxString const &arg4_defvalue = wxPyEmptyString ;
10003 wxString *arg4 = (wxString *) &arg4_defvalue ;
10004 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
10005 wxFont *result;
10006 bool temp4 = false ;
10007 PyObject * obj0 = 0 ;
10008 PyObject * obj1 = 0 ;
10009 PyObject * obj2 = 0 ;
10010 PyObject * obj3 = 0 ;
10011 PyObject * obj4 = 0 ;
10012 char *kwnames[] = {
10013 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
10014 };
10015
10016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_Font2",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
10017 {
10018 arg1 = (int)(SWIG_As_int(obj0));
10019 if (SWIG_arg_fail(1)) SWIG_fail;
10020 }
10021 {
10022 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
10023 if (SWIG_arg_fail(2)) SWIG_fail;
10024 }
10025 if (obj2) {
10026 {
10027 arg3 = (int)(SWIG_As_int(obj2));
10028 if (SWIG_arg_fail(3)) SWIG_fail;
10029 }
10030 }
10031 if (obj3) {
10032 {
10033 arg4 = wxString_in_helper(obj3);
10034 if (arg4 == NULL) SWIG_fail;
10035 temp4 = true;
10036 }
10037 }
10038 if (obj4) {
10039 {
10040 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
10041 if (SWIG_arg_fail(5)) SWIG_fail;
10042 }
10043 }
10044 {
10045 if (!wxPyCheckForApp()) SWIG_fail;
10046 PyThreadState* __tstate = wxPyBeginAllowThreads();
10047 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
10048
10049 wxPyEndAllowThreads(__tstate);
10050 if (PyErr_Occurred()) SWIG_fail;
10051 }
10052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10053 {
10054 if (temp4)
10055 delete arg4;
10056 }
10057 return resultobj;
10058 fail:
10059 {
10060 if (temp4)
10061 delete arg4;
10062 }
10063 return NULL;
10064 }
10065
10066
10067 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10068 PyObject *resultobj;
10069 wxSize *arg1 = 0 ;
10070 int arg2 ;
10071 int arg3 ;
10072 int arg4 ;
10073 bool arg5 = (bool) false ;
10074 wxString const &arg6_defvalue = wxEmptyString ;
10075 wxString *arg6 = (wxString *) &arg6_defvalue ;
10076 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
10077 wxFont *result;
10078 wxSize temp1 ;
10079 bool temp6 = false ;
10080 PyObject * obj0 = 0 ;
10081 PyObject * obj1 = 0 ;
10082 PyObject * obj2 = 0 ;
10083 PyObject * obj3 = 0 ;
10084 PyObject * obj4 = 0 ;
10085 PyObject * obj5 = 0 ;
10086 PyObject * obj6 = 0 ;
10087 char *kwnames[] = {
10088 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
10089 };
10090
10091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
10092 {
10093 arg1 = &temp1;
10094 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
10095 }
10096 {
10097 arg2 = (int)(SWIG_As_int(obj1));
10098 if (SWIG_arg_fail(2)) SWIG_fail;
10099 }
10100 {
10101 arg3 = (int)(SWIG_As_int(obj2));
10102 if (SWIG_arg_fail(3)) SWIG_fail;
10103 }
10104 {
10105 arg4 = (int)(SWIG_As_int(obj3));
10106 if (SWIG_arg_fail(4)) SWIG_fail;
10107 }
10108 if (obj4) {
10109 {
10110 arg5 = (bool)(SWIG_As_bool(obj4));
10111 if (SWIG_arg_fail(5)) SWIG_fail;
10112 }
10113 }
10114 if (obj5) {
10115 {
10116 arg6 = wxString_in_helper(obj5);
10117 if (arg6 == NULL) SWIG_fail;
10118 temp6 = true;
10119 }
10120 }
10121 if (obj6) {
10122 {
10123 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
10124 if (SWIG_arg_fail(7)) SWIG_fail;
10125 }
10126 }
10127 {
10128 if (!wxPyCheckForApp()) SWIG_fail;
10129 PyThreadState* __tstate = wxPyBeginAllowThreads();
10130 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
10131
10132 wxPyEndAllowThreads(__tstate);
10133 if (PyErr_Occurred()) SWIG_fail;
10134 }
10135 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10136 {
10137 if (temp6)
10138 delete arg6;
10139 }
10140 return resultobj;
10141 fail:
10142 {
10143 if (temp6)
10144 delete arg6;
10145 }
10146 return NULL;
10147 }
10148
10149
10150 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
10151 PyObject *resultobj;
10152 wxFont *arg1 = (wxFont *) 0 ;
10153 bool result;
10154 PyObject * obj0 = 0 ;
10155 char *kwnames[] = {
10156 (char *) "self", NULL
10157 };
10158
10159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
10160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10161 if (SWIG_arg_fail(1)) SWIG_fail;
10162 {
10163 PyThreadState* __tstate = wxPyBeginAllowThreads();
10164 result = (bool)((wxFont const *)arg1)->Ok();
10165
10166 wxPyEndAllowThreads(__tstate);
10167 if (PyErr_Occurred()) SWIG_fail;
10168 }
10169 {
10170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10171 }
10172 return resultobj;
10173 fail:
10174 return NULL;
10175 }
10176
10177
10178 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
10179 PyObject *resultobj;
10180 wxFont *arg1 = (wxFont *) 0 ;
10181 wxFont *arg2 = (wxFont *) 0 ;
10182 bool result;
10183 PyObject * obj0 = 0 ;
10184 PyObject * obj1 = 0 ;
10185 char *kwnames[] = {
10186 (char *) "self",(char *) "other", NULL
10187 };
10188
10189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
10190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10191 if (SWIG_arg_fail(1)) SWIG_fail;
10192 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10193 if (SWIG_arg_fail(2)) SWIG_fail;
10194 {
10195 PyThreadState* __tstate = wxPyBeginAllowThreads();
10196 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
10197
10198 wxPyEndAllowThreads(__tstate);
10199 if (PyErr_Occurred()) SWIG_fail;
10200 }
10201 {
10202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10203 }
10204 return resultobj;
10205 fail:
10206 return NULL;
10207 }
10208
10209
10210 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
10211 PyObject *resultobj;
10212 wxFont *arg1 = (wxFont *) 0 ;
10213 wxFont *arg2 = (wxFont *) 0 ;
10214 bool result;
10215 PyObject * obj0 = 0 ;
10216 PyObject * obj1 = 0 ;
10217 char *kwnames[] = {
10218 (char *) "self",(char *) "other", NULL
10219 };
10220
10221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
10222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10223 if (SWIG_arg_fail(1)) SWIG_fail;
10224 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10225 if (SWIG_arg_fail(2)) SWIG_fail;
10226 {
10227 PyThreadState* __tstate = wxPyBeginAllowThreads();
10228 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
10229
10230 wxPyEndAllowThreads(__tstate);
10231 if (PyErr_Occurred()) SWIG_fail;
10232 }
10233 {
10234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10235 }
10236 return resultobj;
10237 fail:
10238 return NULL;
10239 }
10240
10241
10242 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10243 PyObject *resultobj;
10244 wxFont *arg1 = (wxFont *) 0 ;
10245 int result;
10246 PyObject * obj0 = 0 ;
10247 char *kwnames[] = {
10248 (char *) "self", NULL
10249 };
10250
10251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
10252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10253 if (SWIG_arg_fail(1)) SWIG_fail;
10254 {
10255 PyThreadState* __tstate = wxPyBeginAllowThreads();
10256 result = (int)((wxFont const *)arg1)->GetPointSize();
10257
10258 wxPyEndAllowThreads(__tstate);
10259 if (PyErr_Occurred()) SWIG_fail;
10260 }
10261 {
10262 resultobj = SWIG_From_int((int)(result));
10263 }
10264 return resultobj;
10265 fail:
10266 return NULL;
10267 }
10268
10269
10270 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10271 PyObject *resultobj;
10272 wxFont *arg1 = (wxFont *) 0 ;
10273 wxSize result;
10274 PyObject * obj0 = 0 ;
10275 char *kwnames[] = {
10276 (char *) "self", NULL
10277 };
10278
10279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
10280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10281 if (SWIG_arg_fail(1)) SWIG_fail;
10282 {
10283 PyThreadState* __tstate = wxPyBeginAllowThreads();
10284 result = ((wxFont const *)arg1)->GetPixelSize();
10285
10286 wxPyEndAllowThreads(__tstate);
10287 if (PyErr_Occurred()) SWIG_fail;
10288 }
10289 {
10290 wxSize * resultptr;
10291 resultptr = new wxSize((wxSize &)(result));
10292 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
10293 }
10294 return resultobj;
10295 fail:
10296 return NULL;
10297 }
10298
10299
10300 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
10301 PyObject *resultobj;
10302 wxFont *arg1 = (wxFont *) 0 ;
10303 bool result;
10304 PyObject * obj0 = 0 ;
10305 char *kwnames[] = {
10306 (char *) "self", NULL
10307 };
10308
10309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
10310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10311 if (SWIG_arg_fail(1)) SWIG_fail;
10312 {
10313 PyThreadState* __tstate = wxPyBeginAllowThreads();
10314 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
10315
10316 wxPyEndAllowThreads(__tstate);
10317 if (PyErr_Occurred()) SWIG_fail;
10318 }
10319 {
10320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10321 }
10322 return resultobj;
10323 fail:
10324 return NULL;
10325 }
10326
10327
10328 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10329 PyObject *resultobj;
10330 wxFont *arg1 = (wxFont *) 0 ;
10331 int result;
10332 PyObject * obj0 = 0 ;
10333 char *kwnames[] = {
10334 (char *) "self", NULL
10335 };
10336
10337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
10338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10339 if (SWIG_arg_fail(1)) SWIG_fail;
10340 {
10341 PyThreadState* __tstate = wxPyBeginAllowThreads();
10342 result = (int)((wxFont const *)arg1)->GetFamily();
10343
10344 wxPyEndAllowThreads(__tstate);
10345 if (PyErr_Occurred()) SWIG_fail;
10346 }
10347 {
10348 resultobj = SWIG_From_int((int)(result));
10349 }
10350 return resultobj;
10351 fail:
10352 return NULL;
10353 }
10354
10355
10356 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10357 PyObject *resultobj;
10358 wxFont *arg1 = (wxFont *) 0 ;
10359 int result;
10360 PyObject * obj0 = 0 ;
10361 char *kwnames[] = {
10362 (char *) "self", NULL
10363 };
10364
10365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
10366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10367 if (SWIG_arg_fail(1)) SWIG_fail;
10368 {
10369 PyThreadState* __tstate = wxPyBeginAllowThreads();
10370 result = (int)((wxFont const *)arg1)->GetStyle();
10371
10372 wxPyEndAllowThreads(__tstate);
10373 if (PyErr_Occurred()) SWIG_fail;
10374 }
10375 {
10376 resultobj = SWIG_From_int((int)(result));
10377 }
10378 return resultobj;
10379 fail:
10380 return NULL;
10381 }
10382
10383
10384 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10385 PyObject *resultobj;
10386 wxFont *arg1 = (wxFont *) 0 ;
10387 int result;
10388 PyObject * obj0 = 0 ;
10389 char *kwnames[] = {
10390 (char *) "self", NULL
10391 };
10392
10393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
10394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10395 if (SWIG_arg_fail(1)) SWIG_fail;
10396 {
10397 PyThreadState* __tstate = wxPyBeginAllowThreads();
10398 result = (int)((wxFont const *)arg1)->GetWeight();
10399
10400 wxPyEndAllowThreads(__tstate);
10401 if (PyErr_Occurred()) SWIG_fail;
10402 }
10403 {
10404 resultobj = SWIG_From_int((int)(result));
10405 }
10406 return resultobj;
10407 fail:
10408 return NULL;
10409 }
10410
10411
10412 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10413 PyObject *resultobj;
10414 wxFont *arg1 = (wxFont *) 0 ;
10415 bool result;
10416 PyObject * obj0 = 0 ;
10417 char *kwnames[] = {
10418 (char *) "self", NULL
10419 };
10420
10421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
10422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10423 if (SWIG_arg_fail(1)) SWIG_fail;
10424 {
10425 PyThreadState* __tstate = wxPyBeginAllowThreads();
10426 result = (bool)((wxFont const *)arg1)->GetUnderlined();
10427
10428 wxPyEndAllowThreads(__tstate);
10429 if (PyErr_Occurred()) SWIG_fail;
10430 }
10431 {
10432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10433 }
10434 return resultobj;
10435 fail:
10436 return NULL;
10437 }
10438
10439
10440 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10441 PyObject *resultobj;
10442 wxFont *arg1 = (wxFont *) 0 ;
10443 wxString result;
10444 PyObject * obj0 = 0 ;
10445 char *kwnames[] = {
10446 (char *) "self", NULL
10447 };
10448
10449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
10450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10451 if (SWIG_arg_fail(1)) SWIG_fail;
10452 {
10453 PyThreadState* __tstate = wxPyBeginAllowThreads();
10454 result = ((wxFont const *)arg1)->GetFaceName();
10455
10456 wxPyEndAllowThreads(__tstate);
10457 if (PyErr_Occurred()) SWIG_fail;
10458 }
10459 {
10460 #if wxUSE_UNICODE
10461 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10462 #else
10463 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10464 #endif
10465 }
10466 return resultobj;
10467 fail:
10468 return NULL;
10469 }
10470
10471
10472 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10473 PyObject *resultobj;
10474 wxFont *arg1 = (wxFont *) 0 ;
10475 wxFontEncoding result;
10476 PyObject * obj0 = 0 ;
10477 char *kwnames[] = {
10478 (char *) "self", NULL
10479 };
10480
10481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
10482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10483 if (SWIG_arg_fail(1)) SWIG_fail;
10484 {
10485 PyThreadState* __tstate = wxPyBeginAllowThreads();
10486 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
10487
10488 wxPyEndAllowThreads(__tstate);
10489 if (PyErr_Occurred()) SWIG_fail;
10490 }
10491 resultobj = SWIG_From_int((result));
10492 return resultobj;
10493 fail:
10494 return NULL;
10495 }
10496
10497
10498 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10499 PyObject *resultobj;
10500 wxFont *arg1 = (wxFont *) 0 ;
10501 wxNativeFontInfo *result;
10502 PyObject * obj0 = 0 ;
10503 char *kwnames[] = {
10504 (char *) "self", NULL
10505 };
10506
10507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
10508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10509 if (SWIG_arg_fail(1)) SWIG_fail;
10510 {
10511 PyThreadState* __tstate = wxPyBeginAllowThreads();
10512 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
10513
10514 wxPyEndAllowThreads(__tstate);
10515 if (PyErr_Occurred()) SWIG_fail;
10516 }
10517 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
10518 return resultobj;
10519 fail:
10520 return NULL;
10521 }
10522
10523
10524 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
10525 PyObject *resultobj;
10526 wxFont *arg1 = (wxFont *) 0 ;
10527 bool result;
10528 PyObject * obj0 = 0 ;
10529 char *kwnames[] = {
10530 (char *) "self", NULL
10531 };
10532
10533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
10534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10535 if (SWIG_arg_fail(1)) SWIG_fail;
10536 {
10537 PyThreadState* __tstate = wxPyBeginAllowThreads();
10538 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
10539
10540 wxPyEndAllowThreads(__tstate);
10541 if (PyErr_Occurred()) SWIG_fail;
10542 }
10543 {
10544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10545 }
10546 return resultobj;
10547 fail:
10548 return NULL;
10549 }
10550
10551
10552 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10553 PyObject *resultobj;
10554 wxFont *arg1 = (wxFont *) 0 ;
10555 wxString result;
10556 PyObject * obj0 = 0 ;
10557 char *kwnames[] = {
10558 (char *) "self", NULL
10559 };
10560
10561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) 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 {
10565 PyThreadState* __tstate = wxPyBeginAllowThreads();
10566 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
10567
10568 wxPyEndAllowThreads(__tstate);
10569 if (PyErr_Occurred()) SWIG_fail;
10570 }
10571 {
10572 #if wxUSE_UNICODE
10573 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10574 #else
10575 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10576 #endif
10577 }
10578 return resultobj;
10579 fail:
10580 return NULL;
10581 }
10582
10583
10584 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10585 PyObject *resultobj;
10586 wxFont *arg1 = (wxFont *) 0 ;
10587 wxString result;
10588 PyObject * obj0 = 0 ;
10589 char *kwnames[] = {
10590 (char *) "self", NULL
10591 };
10592
10593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",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 = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
10599
10600 wxPyEndAllowThreads(__tstate);
10601 if (PyErr_Occurred()) SWIG_fail;
10602 }
10603 {
10604 #if wxUSE_UNICODE
10605 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10606 #else
10607 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10608 #endif
10609 }
10610 return resultobj;
10611 fail:
10612 return NULL;
10613 }
10614
10615
10616 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10617 PyObject *resultobj;
10618 wxFont *arg1 = (wxFont *) 0 ;
10619 int arg2 ;
10620 PyObject * obj0 = 0 ;
10621 PyObject * obj1 = 0 ;
10622 char *kwnames[] = {
10623 (char *) "self",(char *) "pointSize", NULL
10624 };
10625
10626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
10627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10628 if (SWIG_arg_fail(1)) SWIG_fail;
10629 {
10630 arg2 = (int)(SWIG_As_int(obj1));
10631 if (SWIG_arg_fail(2)) SWIG_fail;
10632 }
10633 {
10634 PyThreadState* __tstate = wxPyBeginAllowThreads();
10635 (arg1)->SetPointSize(arg2);
10636
10637 wxPyEndAllowThreads(__tstate);
10638 if (PyErr_Occurred()) SWIG_fail;
10639 }
10640 Py_INCREF(Py_None); resultobj = Py_None;
10641 return resultobj;
10642 fail:
10643 return NULL;
10644 }
10645
10646
10647 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10648 PyObject *resultobj;
10649 wxFont *arg1 = (wxFont *) 0 ;
10650 wxSize *arg2 = 0 ;
10651 wxSize temp2 ;
10652 PyObject * obj0 = 0 ;
10653 PyObject * obj1 = 0 ;
10654 char *kwnames[] = {
10655 (char *) "self",(char *) "pixelSize", NULL
10656 };
10657
10658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10660 if (SWIG_arg_fail(1)) SWIG_fail;
10661 {
10662 arg2 = &temp2;
10663 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10664 }
10665 {
10666 PyThreadState* __tstate = wxPyBeginAllowThreads();
10667 (arg1)->SetPixelSize((wxSize const &)*arg2);
10668
10669 wxPyEndAllowThreads(__tstate);
10670 if (PyErr_Occurred()) SWIG_fail;
10671 }
10672 Py_INCREF(Py_None); resultobj = Py_None;
10673 return resultobj;
10674 fail:
10675 return NULL;
10676 }
10677
10678
10679 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10680 PyObject *resultobj;
10681 wxFont *arg1 = (wxFont *) 0 ;
10682 int arg2 ;
10683 PyObject * obj0 = 0 ;
10684 PyObject * obj1 = 0 ;
10685 char *kwnames[] = {
10686 (char *) "self",(char *) "family", NULL
10687 };
10688
10689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10691 if (SWIG_arg_fail(1)) SWIG_fail;
10692 {
10693 arg2 = (int)(SWIG_As_int(obj1));
10694 if (SWIG_arg_fail(2)) SWIG_fail;
10695 }
10696 {
10697 PyThreadState* __tstate = wxPyBeginAllowThreads();
10698 (arg1)->SetFamily(arg2);
10699
10700 wxPyEndAllowThreads(__tstate);
10701 if (PyErr_Occurred()) SWIG_fail;
10702 }
10703 Py_INCREF(Py_None); resultobj = Py_None;
10704 return resultobj;
10705 fail:
10706 return NULL;
10707 }
10708
10709
10710 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10711 PyObject *resultobj;
10712 wxFont *arg1 = (wxFont *) 0 ;
10713 int arg2 ;
10714 PyObject * obj0 = 0 ;
10715 PyObject * obj1 = 0 ;
10716 char *kwnames[] = {
10717 (char *) "self",(char *) "style", NULL
10718 };
10719
10720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10722 if (SWIG_arg_fail(1)) SWIG_fail;
10723 {
10724 arg2 = (int)(SWIG_As_int(obj1));
10725 if (SWIG_arg_fail(2)) SWIG_fail;
10726 }
10727 {
10728 PyThreadState* __tstate = wxPyBeginAllowThreads();
10729 (arg1)->SetStyle(arg2);
10730
10731 wxPyEndAllowThreads(__tstate);
10732 if (PyErr_Occurred()) SWIG_fail;
10733 }
10734 Py_INCREF(Py_None); resultobj = Py_None;
10735 return resultobj;
10736 fail:
10737 return NULL;
10738 }
10739
10740
10741 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10742 PyObject *resultobj;
10743 wxFont *arg1 = (wxFont *) 0 ;
10744 int arg2 ;
10745 PyObject * obj0 = 0 ;
10746 PyObject * obj1 = 0 ;
10747 char *kwnames[] = {
10748 (char *) "self",(char *) "weight", NULL
10749 };
10750
10751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10753 if (SWIG_arg_fail(1)) SWIG_fail;
10754 {
10755 arg2 = (int)(SWIG_As_int(obj1));
10756 if (SWIG_arg_fail(2)) SWIG_fail;
10757 }
10758 {
10759 PyThreadState* __tstate = wxPyBeginAllowThreads();
10760 (arg1)->SetWeight(arg2);
10761
10762 wxPyEndAllowThreads(__tstate);
10763 if (PyErr_Occurred()) SWIG_fail;
10764 }
10765 Py_INCREF(Py_None); resultobj = Py_None;
10766 return resultobj;
10767 fail:
10768 return NULL;
10769 }
10770
10771
10772 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10773 PyObject *resultobj;
10774 wxFont *arg1 = (wxFont *) 0 ;
10775 wxString *arg2 = 0 ;
10776 bool temp2 = false ;
10777 PyObject * obj0 = 0 ;
10778 PyObject * obj1 = 0 ;
10779 char *kwnames[] = {
10780 (char *) "self",(char *) "faceName", NULL
10781 };
10782
10783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10785 if (SWIG_arg_fail(1)) SWIG_fail;
10786 {
10787 arg2 = wxString_in_helper(obj1);
10788 if (arg2 == NULL) SWIG_fail;
10789 temp2 = true;
10790 }
10791 {
10792 PyThreadState* __tstate = wxPyBeginAllowThreads();
10793 (arg1)->SetFaceName((wxString const &)*arg2);
10794
10795 wxPyEndAllowThreads(__tstate);
10796 if (PyErr_Occurred()) SWIG_fail;
10797 }
10798 Py_INCREF(Py_None); resultobj = Py_None;
10799 {
10800 if (temp2)
10801 delete arg2;
10802 }
10803 return resultobj;
10804 fail:
10805 {
10806 if (temp2)
10807 delete arg2;
10808 }
10809 return NULL;
10810 }
10811
10812
10813 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10814 PyObject *resultobj;
10815 wxFont *arg1 = (wxFont *) 0 ;
10816 bool arg2 ;
10817 PyObject * obj0 = 0 ;
10818 PyObject * obj1 = 0 ;
10819 char *kwnames[] = {
10820 (char *) "self",(char *) "underlined", NULL
10821 };
10822
10823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10825 if (SWIG_arg_fail(1)) SWIG_fail;
10826 {
10827 arg2 = (bool)(SWIG_As_bool(obj1));
10828 if (SWIG_arg_fail(2)) SWIG_fail;
10829 }
10830 {
10831 PyThreadState* __tstate = wxPyBeginAllowThreads();
10832 (arg1)->SetUnderlined(arg2);
10833
10834 wxPyEndAllowThreads(__tstate);
10835 if (PyErr_Occurred()) SWIG_fail;
10836 }
10837 Py_INCREF(Py_None); resultobj = Py_None;
10838 return resultobj;
10839 fail:
10840 return NULL;
10841 }
10842
10843
10844 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10845 PyObject *resultobj;
10846 wxFont *arg1 = (wxFont *) 0 ;
10847 wxFontEncoding arg2 ;
10848 PyObject * obj0 = 0 ;
10849 PyObject * obj1 = 0 ;
10850 char *kwnames[] = {
10851 (char *) "self",(char *) "encoding", NULL
10852 };
10853
10854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10856 if (SWIG_arg_fail(1)) SWIG_fail;
10857 {
10858 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10859 if (SWIG_arg_fail(2)) SWIG_fail;
10860 }
10861 {
10862 PyThreadState* __tstate = wxPyBeginAllowThreads();
10863 (arg1)->SetEncoding((wxFontEncoding )arg2);
10864
10865 wxPyEndAllowThreads(__tstate);
10866 if (PyErr_Occurred()) SWIG_fail;
10867 }
10868 Py_INCREF(Py_None); resultobj = Py_None;
10869 return resultobj;
10870 fail:
10871 return NULL;
10872 }
10873
10874
10875 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10876 PyObject *resultobj;
10877 wxFont *arg1 = (wxFont *) 0 ;
10878 wxNativeFontInfo *arg2 = 0 ;
10879 PyObject * obj0 = 0 ;
10880 PyObject * obj1 = 0 ;
10881 char *kwnames[] = {
10882 (char *) "self",(char *) "info", NULL
10883 };
10884
10885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10887 if (SWIG_arg_fail(1)) SWIG_fail;
10888 {
10889 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10890 if (SWIG_arg_fail(2)) SWIG_fail;
10891 if (arg2 == NULL) {
10892 SWIG_null_ref("wxNativeFontInfo");
10893 }
10894 if (SWIG_arg_fail(2)) SWIG_fail;
10895 }
10896 {
10897 PyThreadState* __tstate = wxPyBeginAllowThreads();
10898 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10899
10900 wxPyEndAllowThreads(__tstate);
10901 if (PyErr_Occurred()) SWIG_fail;
10902 }
10903 Py_INCREF(Py_None); resultobj = Py_None;
10904 return resultobj;
10905 fail:
10906 return NULL;
10907 }
10908
10909
10910 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10911 PyObject *resultobj;
10912 wxFont *arg1 = (wxFont *) 0 ;
10913 wxString *arg2 = 0 ;
10914 bool temp2 = false ;
10915 PyObject * obj0 = 0 ;
10916 PyObject * obj1 = 0 ;
10917 char *kwnames[] = {
10918 (char *) "self",(char *) "info", NULL
10919 };
10920
10921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10923 if (SWIG_arg_fail(1)) SWIG_fail;
10924 {
10925 arg2 = wxString_in_helper(obj1);
10926 if (arg2 == NULL) SWIG_fail;
10927 temp2 = true;
10928 }
10929 {
10930 PyThreadState* __tstate = wxPyBeginAllowThreads();
10931 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10932
10933 wxPyEndAllowThreads(__tstate);
10934 if (PyErr_Occurred()) SWIG_fail;
10935 }
10936 Py_INCREF(Py_None); resultobj = Py_None;
10937 {
10938 if (temp2)
10939 delete arg2;
10940 }
10941 return resultobj;
10942 fail:
10943 {
10944 if (temp2)
10945 delete arg2;
10946 }
10947 return NULL;
10948 }
10949
10950
10951 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10952 PyObject *resultobj;
10953 wxFont *arg1 = (wxFont *) 0 ;
10954 wxString *arg2 = 0 ;
10955 bool temp2 = false ;
10956 PyObject * obj0 = 0 ;
10957 PyObject * obj1 = 0 ;
10958 char *kwnames[] = {
10959 (char *) "self",(char *) "info", NULL
10960 };
10961
10962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10964 if (SWIG_arg_fail(1)) SWIG_fail;
10965 {
10966 arg2 = wxString_in_helper(obj1);
10967 if (arg2 == NULL) SWIG_fail;
10968 temp2 = true;
10969 }
10970 {
10971 PyThreadState* __tstate = wxPyBeginAllowThreads();
10972 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
10973
10974 wxPyEndAllowThreads(__tstate);
10975 if (PyErr_Occurred()) SWIG_fail;
10976 }
10977 Py_INCREF(Py_None); resultobj = Py_None;
10978 {
10979 if (temp2)
10980 delete arg2;
10981 }
10982 return resultobj;
10983 fail:
10984 {
10985 if (temp2)
10986 delete arg2;
10987 }
10988 return NULL;
10989 }
10990
10991
10992 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
10993 PyObject *resultobj;
10994 wxFont *arg1 = (wxFont *) 0 ;
10995 wxString result;
10996 PyObject * obj0 = 0 ;
10997 char *kwnames[] = {
10998 (char *) "self", NULL
10999 };
11000
11001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
11002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11003 if (SWIG_arg_fail(1)) SWIG_fail;
11004 {
11005 PyThreadState* __tstate = wxPyBeginAllowThreads();
11006 result = ((wxFont const *)arg1)->GetFamilyString();
11007
11008 wxPyEndAllowThreads(__tstate);
11009 if (PyErr_Occurred()) SWIG_fail;
11010 }
11011 {
11012 #if wxUSE_UNICODE
11013 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11014 #else
11015 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11016 #endif
11017 }
11018 return resultobj;
11019 fail:
11020 return NULL;
11021 }
11022
11023
11024 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
11025 PyObject *resultobj;
11026 wxFont *arg1 = (wxFont *) 0 ;
11027 wxString result;
11028 PyObject * obj0 = 0 ;
11029 char *kwnames[] = {
11030 (char *) "self", NULL
11031 };
11032
11033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
11034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11035 if (SWIG_arg_fail(1)) SWIG_fail;
11036 {
11037 PyThreadState* __tstate = wxPyBeginAllowThreads();
11038 result = ((wxFont const *)arg1)->GetStyleString();
11039
11040 wxPyEndAllowThreads(__tstate);
11041 if (PyErr_Occurred()) SWIG_fail;
11042 }
11043 {
11044 #if wxUSE_UNICODE
11045 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11046 #else
11047 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11048 #endif
11049 }
11050 return resultobj;
11051 fail:
11052 return NULL;
11053 }
11054
11055
11056 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
11057 PyObject *resultobj;
11058 wxFont *arg1 = (wxFont *) 0 ;
11059 wxString result;
11060 PyObject * obj0 = 0 ;
11061 char *kwnames[] = {
11062 (char *) "self", NULL
11063 };
11064
11065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
11066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11067 if (SWIG_arg_fail(1)) SWIG_fail;
11068 {
11069 PyThreadState* __tstate = wxPyBeginAllowThreads();
11070 result = ((wxFont const *)arg1)->GetWeightString();
11071
11072 wxPyEndAllowThreads(__tstate);
11073 if (PyErr_Occurred()) SWIG_fail;
11074 }
11075 {
11076 #if wxUSE_UNICODE
11077 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11078 #else
11079 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11080 #endif
11081 }
11082 return resultobj;
11083 fail:
11084 return NULL;
11085 }
11086
11087
11088 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
11089 PyObject *resultobj;
11090 wxFont *arg1 = (wxFont *) 0 ;
11091 bool arg2 = (bool) true ;
11092 PyObject * obj0 = 0 ;
11093 PyObject * obj1 = 0 ;
11094 char *kwnames[] = {
11095 (char *) "self",(char *) "no", NULL
11096 };
11097
11098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
11099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11100 if (SWIG_arg_fail(1)) SWIG_fail;
11101 if (obj1) {
11102 {
11103 arg2 = (bool)(SWIG_As_bool(obj1));
11104 if (SWIG_arg_fail(2)) SWIG_fail;
11105 }
11106 }
11107 {
11108 PyThreadState* __tstate = wxPyBeginAllowThreads();
11109 (arg1)->SetNoAntiAliasing(arg2);
11110
11111 wxPyEndAllowThreads(__tstate);
11112 if (PyErr_Occurred()) SWIG_fail;
11113 }
11114 Py_INCREF(Py_None); resultobj = Py_None;
11115 return resultobj;
11116 fail:
11117 return NULL;
11118 }
11119
11120
11121 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
11122 PyObject *resultobj;
11123 wxFont *arg1 = (wxFont *) 0 ;
11124 bool result;
11125 PyObject * obj0 = 0 ;
11126 char *kwnames[] = {
11127 (char *) "self", NULL
11128 };
11129
11130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
11131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11132 if (SWIG_arg_fail(1)) SWIG_fail;
11133 {
11134 PyThreadState* __tstate = wxPyBeginAllowThreads();
11135 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
11136
11137 wxPyEndAllowThreads(__tstate);
11138 if (PyErr_Occurred()) SWIG_fail;
11139 }
11140 {
11141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11142 }
11143 return resultobj;
11144 fail:
11145 return NULL;
11146 }
11147
11148
11149 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11150 PyObject *resultobj;
11151 wxFontEncoding result;
11152 char *kwnames[] = {
11153 NULL
11154 };
11155
11156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
11157 {
11158 if (!wxPyCheckForApp()) SWIG_fail;
11159 PyThreadState* __tstate = wxPyBeginAllowThreads();
11160 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
11161
11162 wxPyEndAllowThreads(__tstate);
11163 if (PyErr_Occurred()) SWIG_fail;
11164 }
11165 resultobj = SWIG_From_int((result));
11166 return resultobj;
11167 fail:
11168 return NULL;
11169 }
11170
11171
11172 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11173 PyObject *resultobj;
11174 wxFontEncoding arg1 ;
11175 PyObject * obj0 = 0 ;
11176 char *kwnames[] = {
11177 (char *) "encoding", NULL
11178 };
11179
11180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
11181 {
11182 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
11183 if (SWIG_arg_fail(1)) SWIG_fail;
11184 }
11185 {
11186 if (!wxPyCheckForApp()) SWIG_fail;
11187 PyThreadState* __tstate = wxPyBeginAllowThreads();
11188 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
11189
11190 wxPyEndAllowThreads(__tstate);
11191 if (PyErr_Occurred()) SWIG_fail;
11192 }
11193 Py_INCREF(Py_None); resultobj = Py_None;
11194 return resultobj;
11195 fail:
11196 return NULL;
11197 }
11198
11199
11200 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
11201 PyObject *obj;
11202 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11203 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
11204 Py_INCREF(obj);
11205 return Py_BuildValue((char *)"");
11206 }
11207 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
11208 PyObject *resultobj;
11209 wxPyFontEnumerator *result;
11210 char *kwnames[] = {
11211 NULL
11212 };
11213
11214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
11215 {
11216 if (!wxPyCheckForApp()) SWIG_fail;
11217 PyThreadState* __tstate = wxPyBeginAllowThreads();
11218 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
11219
11220 wxPyEndAllowThreads(__tstate);
11221 if (PyErr_Occurred()) SWIG_fail;
11222 }
11223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
11224 return resultobj;
11225 fail:
11226 return NULL;
11227 }
11228
11229
11230 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
11231 PyObject *resultobj;
11232 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11233 PyObject * obj0 = 0 ;
11234 char *kwnames[] = {
11235 (char *) "self", NULL
11236 };
11237
11238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
11239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11240 if (SWIG_arg_fail(1)) SWIG_fail;
11241 {
11242 PyThreadState* __tstate = wxPyBeginAllowThreads();
11243 delete arg1;
11244
11245 wxPyEndAllowThreads(__tstate);
11246 if (PyErr_Occurred()) SWIG_fail;
11247 }
11248 Py_INCREF(Py_None); resultobj = Py_None;
11249 return resultobj;
11250 fail:
11251 return NULL;
11252 }
11253
11254
11255 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11256 PyObject *resultobj;
11257 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11258 PyObject *arg2 = (PyObject *) 0 ;
11259 PyObject *arg3 = (PyObject *) 0 ;
11260 bool arg4 ;
11261 PyObject * obj0 = 0 ;
11262 PyObject * obj1 = 0 ;
11263 PyObject * obj2 = 0 ;
11264 PyObject * obj3 = 0 ;
11265 char *kwnames[] = {
11266 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11267 };
11268
11269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11271 if (SWIG_arg_fail(1)) SWIG_fail;
11272 arg2 = obj1;
11273 arg3 = obj2;
11274 {
11275 arg4 = (bool)(SWIG_As_bool(obj3));
11276 if (SWIG_arg_fail(4)) SWIG_fail;
11277 }
11278 {
11279 PyThreadState* __tstate = wxPyBeginAllowThreads();
11280 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11281
11282 wxPyEndAllowThreads(__tstate);
11283 if (PyErr_Occurred()) SWIG_fail;
11284 }
11285 Py_INCREF(Py_None); resultobj = Py_None;
11286 return resultobj;
11287 fail:
11288 return NULL;
11289 }
11290
11291
11292 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
11293 PyObject *resultobj;
11294 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11295 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
11296 bool arg3 = (bool) false ;
11297 bool result;
11298 PyObject * obj0 = 0 ;
11299 PyObject * obj1 = 0 ;
11300 PyObject * obj2 = 0 ;
11301 char *kwnames[] = {
11302 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
11303 };
11304
11305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
11306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11307 if (SWIG_arg_fail(1)) SWIG_fail;
11308 if (obj1) {
11309 {
11310 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
11311 if (SWIG_arg_fail(2)) SWIG_fail;
11312 }
11313 }
11314 if (obj2) {
11315 {
11316 arg3 = (bool)(SWIG_As_bool(obj2));
11317 if (SWIG_arg_fail(3)) SWIG_fail;
11318 }
11319 }
11320 {
11321 PyThreadState* __tstate = wxPyBeginAllowThreads();
11322 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
11323
11324 wxPyEndAllowThreads(__tstate);
11325 if (PyErr_Occurred()) SWIG_fail;
11326 }
11327 {
11328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11329 }
11330 return resultobj;
11331 fail:
11332 return NULL;
11333 }
11334
11335
11336 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
11337 PyObject *resultobj;
11338 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11339 wxString const &arg2_defvalue = wxPyEmptyString ;
11340 wxString *arg2 = (wxString *) &arg2_defvalue ;
11341 bool result;
11342 bool temp2 = false ;
11343 PyObject * obj0 = 0 ;
11344 PyObject * obj1 = 0 ;
11345 char *kwnames[] = {
11346 (char *) "self",(char *) "facename", NULL
11347 };
11348
11349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
11350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11351 if (SWIG_arg_fail(1)) SWIG_fail;
11352 if (obj1) {
11353 {
11354 arg2 = wxString_in_helper(obj1);
11355 if (arg2 == NULL) SWIG_fail;
11356 temp2 = true;
11357 }
11358 }
11359 {
11360 PyThreadState* __tstate = wxPyBeginAllowThreads();
11361 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
11362
11363 wxPyEndAllowThreads(__tstate);
11364 if (PyErr_Occurred()) SWIG_fail;
11365 }
11366 {
11367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11368 }
11369 {
11370 if (temp2)
11371 delete arg2;
11372 }
11373 return resultobj;
11374 fail:
11375 {
11376 if (temp2)
11377 delete arg2;
11378 }
11379 return NULL;
11380 }
11381
11382
11383 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
11384 PyObject *resultobj;
11385 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11386 PyObject *result;
11387 PyObject * obj0 = 0 ;
11388 char *kwnames[] = {
11389 (char *) "self", NULL
11390 };
11391
11392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
11393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11394 if (SWIG_arg_fail(1)) SWIG_fail;
11395 {
11396 PyThreadState* __tstate = wxPyBeginAllowThreads();
11397 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
11398
11399 wxPyEndAllowThreads(__tstate);
11400 if (PyErr_Occurred()) SWIG_fail;
11401 }
11402 resultobj = result;
11403 return resultobj;
11404 fail:
11405 return NULL;
11406 }
11407
11408
11409 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
11410 PyObject *resultobj;
11411 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11412 PyObject *result;
11413 PyObject * obj0 = 0 ;
11414 char *kwnames[] = {
11415 (char *) "self", NULL
11416 };
11417
11418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
11419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11420 if (SWIG_arg_fail(1)) SWIG_fail;
11421 {
11422 PyThreadState* __tstate = wxPyBeginAllowThreads();
11423 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
11424
11425 wxPyEndAllowThreads(__tstate);
11426 if (PyErr_Occurred()) SWIG_fail;
11427 }
11428 resultobj = result;
11429 return resultobj;
11430 fail:
11431 return NULL;
11432 }
11433
11434
11435 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
11436 PyObject *obj;
11437 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11438 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
11439 Py_INCREF(obj);
11440 return Py_BuildValue((char *)"");
11441 }
11442 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
11443 PyObject *resultobj;
11444 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11445 int arg2 ;
11446 PyObject * obj0 = 0 ;
11447 PyObject * obj1 = 0 ;
11448 char *kwnames[] = {
11449 (char *) "self",(char *) "Language", NULL
11450 };
11451
11452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
11453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11454 if (SWIG_arg_fail(1)) SWIG_fail;
11455 {
11456 arg2 = (int)(SWIG_As_int(obj1));
11457 if (SWIG_arg_fail(2)) SWIG_fail;
11458 }
11459 if (arg1) (arg1)->Language = arg2;
11460
11461 Py_INCREF(Py_None); resultobj = Py_None;
11462 return resultobj;
11463 fail:
11464 return NULL;
11465 }
11466
11467
11468 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
11469 PyObject *resultobj;
11470 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11471 int result;
11472 PyObject * obj0 = 0 ;
11473 char *kwnames[] = {
11474 (char *) "self", NULL
11475 };
11476
11477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
11478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11479 if (SWIG_arg_fail(1)) SWIG_fail;
11480 result = (int) ((arg1)->Language);
11481
11482 {
11483 resultobj = SWIG_From_int((int)(result));
11484 }
11485 return resultobj;
11486 fail:
11487 return NULL;
11488 }
11489
11490
11491 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
11492 PyObject *resultobj;
11493 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11494 wxString *arg2 = (wxString *) 0 ;
11495 bool temp2 = false ;
11496 PyObject * obj0 = 0 ;
11497 PyObject * obj1 = 0 ;
11498 char *kwnames[] = {
11499 (char *) "self",(char *) "CanonicalName", NULL
11500 };
11501
11502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
11503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11504 if (SWIG_arg_fail(1)) SWIG_fail;
11505 {
11506 arg2 = wxString_in_helper(obj1);
11507 if (arg2 == NULL) SWIG_fail;
11508 temp2 = true;
11509 }
11510 if (arg1) (arg1)->CanonicalName = *arg2;
11511
11512 Py_INCREF(Py_None); resultobj = Py_None;
11513 {
11514 if (temp2)
11515 delete arg2;
11516 }
11517 return resultobj;
11518 fail:
11519 {
11520 if (temp2)
11521 delete arg2;
11522 }
11523 return NULL;
11524 }
11525
11526
11527 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
11528 PyObject *resultobj;
11529 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11530 wxString *result;
11531 PyObject * obj0 = 0 ;
11532 char *kwnames[] = {
11533 (char *) "self", NULL
11534 };
11535
11536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
11537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11538 if (SWIG_arg_fail(1)) SWIG_fail;
11539 result = (wxString *)& ((arg1)->CanonicalName);
11540
11541 {
11542 #if wxUSE_UNICODE
11543 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11544 #else
11545 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11546 #endif
11547 }
11548 return resultobj;
11549 fail:
11550 return NULL;
11551 }
11552
11553
11554 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
11555 PyObject *resultobj;
11556 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11557 wxString *arg2 = (wxString *) 0 ;
11558 bool temp2 = false ;
11559 PyObject * obj0 = 0 ;
11560 PyObject * obj1 = 0 ;
11561 char *kwnames[] = {
11562 (char *) "self",(char *) "Description", NULL
11563 };
11564
11565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
11566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11567 if (SWIG_arg_fail(1)) SWIG_fail;
11568 {
11569 arg2 = wxString_in_helper(obj1);
11570 if (arg2 == NULL) SWIG_fail;
11571 temp2 = true;
11572 }
11573 if (arg1) (arg1)->Description = *arg2;
11574
11575 Py_INCREF(Py_None); resultobj = Py_None;
11576 {
11577 if (temp2)
11578 delete arg2;
11579 }
11580 return resultobj;
11581 fail:
11582 {
11583 if (temp2)
11584 delete arg2;
11585 }
11586 return NULL;
11587 }
11588
11589
11590 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
11591 PyObject *resultobj;
11592 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11593 wxString *result;
11594 PyObject * obj0 = 0 ;
11595 char *kwnames[] = {
11596 (char *) "self", NULL
11597 };
11598
11599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
11600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11601 if (SWIG_arg_fail(1)) SWIG_fail;
11602 result = (wxString *)& ((arg1)->Description);
11603
11604 {
11605 #if wxUSE_UNICODE
11606 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11607 #else
11608 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11609 #endif
11610 }
11611 return resultobj;
11612 fail:
11613 return NULL;
11614 }
11615
11616
11617 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
11618 PyObject *obj;
11619 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11620 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
11621 Py_INCREF(obj);
11622 return Py_BuildValue((char *)"");
11623 }
11624 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11625 PyObject *resultobj;
11626 int arg1 = (int) -1 ;
11627 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11628 wxLocale *result;
11629 PyObject * obj0 = 0 ;
11630 PyObject * obj1 = 0 ;
11631 char *kwnames[] = {
11632 (char *) "language",(char *) "flags", NULL
11633 };
11634
11635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
11636 if (obj0) {
11637 {
11638 arg1 = (int)(SWIG_As_int(obj0));
11639 if (SWIG_arg_fail(1)) SWIG_fail;
11640 }
11641 }
11642 if (obj1) {
11643 {
11644 arg2 = (int)(SWIG_As_int(obj1));
11645 if (SWIG_arg_fail(2)) SWIG_fail;
11646 }
11647 }
11648 {
11649 PyThreadState* __tstate = wxPyBeginAllowThreads();
11650 result = (wxLocale *)new_wxLocale(arg1,arg2);
11651
11652 wxPyEndAllowThreads(__tstate);
11653 if (PyErr_Occurred()) SWIG_fail;
11654 }
11655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11656 return resultobj;
11657 fail:
11658 return NULL;
11659 }
11660
11661
11662 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11663 PyObject *resultobj;
11664 wxLocale *arg1 = (wxLocale *) 0 ;
11665 PyObject * obj0 = 0 ;
11666 char *kwnames[] = {
11667 (char *) "self", NULL
11668 };
11669
11670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11672 if (SWIG_arg_fail(1)) SWIG_fail;
11673 {
11674 PyThreadState* __tstate = wxPyBeginAllowThreads();
11675 delete arg1;
11676
11677 wxPyEndAllowThreads(__tstate);
11678 if (PyErr_Occurred()) SWIG_fail;
11679 }
11680 Py_INCREF(Py_None); resultobj = Py_None;
11681 return resultobj;
11682 fail:
11683 return NULL;
11684 }
11685
11686
11687 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11688 PyObject *resultobj;
11689 wxLocale *arg1 = (wxLocale *) 0 ;
11690 wxString *arg2 = 0 ;
11691 wxString const &arg3_defvalue = wxPyEmptyString ;
11692 wxString *arg3 = (wxString *) &arg3_defvalue ;
11693 wxString const &arg4_defvalue = wxPyEmptyString ;
11694 wxString *arg4 = (wxString *) &arg4_defvalue ;
11695 bool arg5 = (bool) true ;
11696 bool arg6 = (bool) false ;
11697 bool result;
11698 bool temp2 = false ;
11699 bool temp3 = false ;
11700 bool temp4 = false ;
11701 PyObject * obj0 = 0 ;
11702 PyObject * obj1 = 0 ;
11703 PyObject * obj2 = 0 ;
11704 PyObject * obj3 = 0 ;
11705 PyObject * obj4 = 0 ;
11706 PyObject * obj5 = 0 ;
11707 char *kwnames[] = {
11708 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11709 };
11710
11711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11713 if (SWIG_arg_fail(1)) SWIG_fail;
11714 {
11715 arg2 = wxString_in_helper(obj1);
11716 if (arg2 == NULL) SWIG_fail;
11717 temp2 = true;
11718 }
11719 if (obj2) {
11720 {
11721 arg3 = wxString_in_helper(obj2);
11722 if (arg3 == NULL) SWIG_fail;
11723 temp3 = true;
11724 }
11725 }
11726 if (obj3) {
11727 {
11728 arg4 = wxString_in_helper(obj3);
11729 if (arg4 == NULL) SWIG_fail;
11730 temp4 = true;
11731 }
11732 }
11733 if (obj4) {
11734 {
11735 arg5 = (bool)(SWIG_As_bool(obj4));
11736 if (SWIG_arg_fail(5)) SWIG_fail;
11737 }
11738 }
11739 if (obj5) {
11740 {
11741 arg6 = (bool)(SWIG_As_bool(obj5));
11742 if (SWIG_arg_fail(6)) SWIG_fail;
11743 }
11744 }
11745 {
11746 PyThreadState* __tstate = wxPyBeginAllowThreads();
11747 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11748
11749 wxPyEndAllowThreads(__tstate);
11750 if (PyErr_Occurred()) SWIG_fail;
11751 }
11752 {
11753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11754 }
11755 {
11756 if (temp2)
11757 delete arg2;
11758 }
11759 {
11760 if (temp3)
11761 delete arg3;
11762 }
11763 {
11764 if (temp4)
11765 delete arg4;
11766 }
11767 return resultobj;
11768 fail:
11769 {
11770 if (temp2)
11771 delete arg2;
11772 }
11773 {
11774 if (temp3)
11775 delete arg3;
11776 }
11777 {
11778 if (temp4)
11779 delete arg4;
11780 }
11781 return NULL;
11782 }
11783
11784
11785 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11786 PyObject *resultobj;
11787 wxLocale *arg1 = (wxLocale *) 0 ;
11788 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11789 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11790 bool result;
11791 PyObject * obj0 = 0 ;
11792 PyObject * obj1 = 0 ;
11793 PyObject * obj2 = 0 ;
11794 char *kwnames[] = {
11795 (char *) "self",(char *) "language",(char *) "flags", NULL
11796 };
11797
11798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11800 if (SWIG_arg_fail(1)) SWIG_fail;
11801 if (obj1) {
11802 {
11803 arg2 = (int)(SWIG_As_int(obj1));
11804 if (SWIG_arg_fail(2)) SWIG_fail;
11805 }
11806 }
11807 if (obj2) {
11808 {
11809 arg3 = (int)(SWIG_As_int(obj2));
11810 if (SWIG_arg_fail(3)) SWIG_fail;
11811 }
11812 }
11813 {
11814 PyThreadState* __tstate = wxPyBeginAllowThreads();
11815 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11816
11817 wxPyEndAllowThreads(__tstate);
11818 if (PyErr_Occurred()) SWIG_fail;
11819 }
11820 {
11821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11822 }
11823 return resultobj;
11824 fail:
11825 return NULL;
11826 }
11827
11828
11829 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11830 PyObject *resultobj;
11831 int result;
11832 char *kwnames[] = {
11833 NULL
11834 };
11835
11836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11837 {
11838 PyThreadState* __tstate = wxPyBeginAllowThreads();
11839 result = (int)wxLocale::GetSystemLanguage();
11840
11841 wxPyEndAllowThreads(__tstate);
11842 if (PyErr_Occurred()) SWIG_fail;
11843 }
11844 {
11845 resultobj = SWIG_From_int((int)(result));
11846 }
11847 return resultobj;
11848 fail:
11849 return NULL;
11850 }
11851
11852
11853 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11854 PyObject *resultobj;
11855 wxFontEncoding result;
11856 char *kwnames[] = {
11857 NULL
11858 };
11859
11860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11861 {
11862 PyThreadState* __tstate = wxPyBeginAllowThreads();
11863 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11864
11865 wxPyEndAllowThreads(__tstate);
11866 if (PyErr_Occurred()) SWIG_fail;
11867 }
11868 resultobj = SWIG_From_int((result));
11869 return resultobj;
11870 fail:
11871 return NULL;
11872 }
11873
11874
11875 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11876 PyObject *resultobj;
11877 wxString result;
11878 char *kwnames[] = {
11879 NULL
11880 };
11881
11882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11883 {
11884 PyThreadState* __tstate = wxPyBeginAllowThreads();
11885 result = wxLocale::GetSystemEncodingName();
11886
11887 wxPyEndAllowThreads(__tstate);
11888 if (PyErr_Occurred()) SWIG_fail;
11889 }
11890 {
11891 #if wxUSE_UNICODE
11892 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11893 #else
11894 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11895 #endif
11896 }
11897 return resultobj;
11898 fail:
11899 return NULL;
11900 }
11901
11902
11903 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11904 PyObject *resultobj;
11905 wxLocale *arg1 = (wxLocale *) 0 ;
11906 bool result;
11907 PyObject * obj0 = 0 ;
11908 char *kwnames[] = {
11909 (char *) "self", NULL
11910 };
11911
11912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11914 if (SWIG_arg_fail(1)) SWIG_fail;
11915 {
11916 PyThreadState* __tstate = wxPyBeginAllowThreads();
11917 result = (bool)((wxLocale const *)arg1)->IsOk();
11918
11919 wxPyEndAllowThreads(__tstate);
11920 if (PyErr_Occurred()) SWIG_fail;
11921 }
11922 {
11923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11924 }
11925 return resultobj;
11926 fail:
11927 return NULL;
11928 }
11929
11930
11931 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11932 PyObject *resultobj;
11933 wxLocale *arg1 = (wxLocale *) 0 ;
11934 wxString result;
11935 PyObject * obj0 = 0 ;
11936 char *kwnames[] = {
11937 (char *) "self", NULL
11938 };
11939
11940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11942 if (SWIG_arg_fail(1)) SWIG_fail;
11943 {
11944 PyThreadState* __tstate = wxPyBeginAllowThreads();
11945 result = ((wxLocale const *)arg1)->GetLocale();
11946
11947 wxPyEndAllowThreads(__tstate);
11948 if (PyErr_Occurred()) SWIG_fail;
11949 }
11950 {
11951 #if wxUSE_UNICODE
11952 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11953 #else
11954 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11955 #endif
11956 }
11957 return resultobj;
11958 fail:
11959 return NULL;
11960 }
11961
11962
11963 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11964 PyObject *resultobj;
11965 wxLocale *arg1 = (wxLocale *) 0 ;
11966 int result;
11967 PyObject * obj0 = 0 ;
11968 char *kwnames[] = {
11969 (char *) "self", NULL
11970 };
11971
11972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
11973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11974 if (SWIG_arg_fail(1)) SWIG_fail;
11975 {
11976 PyThreadState* __tstate = wxPyBeginAllowThreads();
11977 result = (int)((wxLocale const *)arg1)->GetLanguage();
11978
11979 wxPyEndAllowThreads(__tstate);
11980 if (PyErr_Occurred()) SWIG_fail;
11981 }
11982 {
11983 resultobj = SWIG_From_int((int)(result));
11984 }
11985 return resultobj;
11986 fail:
11987 return NULL;
11988 }
11989
11990
11991 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
11992 PyObject *resultobj;
11993 wxLocale *arg1 = (wxLocale *) 0 ;
11994 wxString result;
11995 PyObject * obj0 = 0 ;
11996 char *kwnames[] = {
11997 (char *) "self", NULL
11998 };
11999
12000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
12001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12002 if (SWIG_arg_fail(1)) SWIG_fail;
12003 {
12004 PyThreadState* __tstate = wxPyBeginAllowThreads();
12005 result = ((wxLocale const *)arg1)->GetSysName();
12006
12007 wxPyEndAllowThreads(__tstate);
12008 if (PyErr_Occurred()) SWIG_fail;
12009 }
12010 {
12011 #if wxUSE_UNICODE
12012 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12013 #else
12014 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12015 #endif
12016 }
12017 return resultobj;
12018 fail:
12019 return NULL;
12020 }
12021
12022
12023 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
12024 PyObject *resultobj;
12025 wxLocale *arg1 = (wxLocale *) 0 ;
12026 wxString result;
12027 PyObject * obj0 = 0 ;
12028 char *kwnames[] = {
12029 (char *) "self", NULL
12030 };
12031
12032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
12033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12034 if (SWIG_arg_fail(1)) SWIG_fail;
12035 {
12036 PyThreadState* __tstate = wxPyBeginAllowThreads();
12037 result = ((wxLocale const *)arg1)->GetCanonicalName();
12038
12039 wxPyEndAllowThreads(__tstate);
12040 if (PyErr_Occurred()) SWIG_fail;
12041 }
12042 {
12043 #if wxUSE_UNICODE
12044 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12045 #else
12046 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12047 #endif
12048 }
12049 return resultobj;
12050 fail:
12051 return NULL;
12052 }
12053
12054
12055 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
12056 PyObject *resultobj;
12057 wxString *arg1 = 0 ;
12058 bool temp1 = false ;
12059 PyObject * obj0 = 0 ;
12060 char *kwnames[] = {
12061 (char *) "prefix", NULL
12062 };
12063
12064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
12065 {
12066 arg1 = wxString_in_helper(obj0);
12067 if (arg1 == NULL) SWIG_fail;
12068 temp1 = true;
12069 }
12070 {
12071 PyThreadState* __tstate = wxPyBeginAllowThreads();
12072 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
12073
12074 wxPyEndAllowThreads(__tstate);
12075 if (PyErr_Occurred()) SWIG_fail;
12076 }
12077 Py_INCREF(Py_None); resultobj = Py_None;
12078 {
12079 if (temp1)
12080 delete arg1;
12081 }
12082 return resultobj;
12083 fail:
12084 {
12085 if (temp1)
12086 delete arg1;
12087 }
12088 return NULL;
12089 }
12090
12091
12092 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
12093 PyObject *resultobj;
12094 wxLocale *arg1 = (wxLocale *) 0 ;
12095 wxString *arg2 = 0 ;
12096 bool result;
12097 bool temp2 = false ;
12098 PyObject * obj0 = 0 ;
12099 PyObject * obj1 = 0 ;
12100 char *kwnames[] = {
12101 (char *) "self",(char *) "szDomain", NULL
12102 };
12103
12104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
12105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12106 if (SWIG_arg_fail(1)) SWIG_fail;
12107 {
12108 arg2 = wxString_in_helper(obj1);
12109 if (arg2 == NULL) SWIG_fail;
12110 temp2 = true;
12111 }
12112 {
12113 PyThreadState* __tstate = wxPyBeginAllowThreads();
12114 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
12115
12116 wxPyEndAllowThreads(__tstate);
12117 if (PyErr_Occurred()) SWIG_fail;
12118 }
12119 {
12120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12121 }
12122 {
12123 if (temp2)
12124 delete arg2;
12125 }
12126 return resultobj;
12127 fail:
12128 {
12129 if (temp2)
12130 delete arg2;
12131 }
12132 return NULL;
12133 }
12134
12135
12136 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
12137 PyObject *resultobj;
12138 wxLocale *arg1 = (wxLocale *) 0 ;
12139 wxString *arg2 = 0 ;
12140 bool result;
12141 bool temp2 = false ;
12142 PyObject * obj0 = 0 ;
12143 PyObject * obj1 = 0 ;
12144 char *kwnames[] = {
12145 (char *) "self",(char *) "szDomain", NULL
12146 };
12147
12148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
12149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12150 if (SWIG_arg_fail(1)) SWIG_fail;
12151 {
12152 arg2 = wxString_in_helper(obj1);
12153 if (arg2 == NULL) SWIG_fail;
12154 temp2 = true;
12155 }
12156 {
12157 PyThreadState* __tstate = wxPyBeginAllowThreads();
12158 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
12159
12160 wxPyEndAllowThreads(__tstate);
12161 if (PyErr_Occurred()) SWIG_fail;
12162 }
12163 {
12164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12165 }
12166 {
12167 if (temp2)
12168 delete arg2;
12169 }
12170 return resultobj;
12171 fail:
12172 {
12173 if (temp2)
12174 delete arg2;
12175 }
12176 return NULL;
12177 }
12178
12179
12180 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12181 PyObject *resultobj;
12182 int arg1 ;
12183 wxLanguageInfo *result;
12184 PyObject * obj0 = 0 ;
12185 char *kwnames[] = {
12186 (char *) "lang", NULL
12187 };
12188
12189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
12190 {
12191 arg1 = (int)(SWIG_As_int(obj0));
12192 if (SWIG_arg_fail(1)) SWIG_fail;
12193 }
12194 {
12195 PyThreadState* __tstate = wxPyBeginAllowThreads();
12196 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
12197
12198 wxPyEndAllowThreads(__tstate);
12199 if (PyErr_Occurred()) SWIG_fail;
12200 }
12201 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
12202 return resultobj;
12203 fail:
12204 return NULL;
12205 }
12206
12207
12208 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
12209 PyObject *resultobj;
12210 int arg1 ;
12211 wxString result;
12212 PyObject * obj0 = 0 ;
12213 char *kwnames[] = {
12214 (char *) "lang", NULL
12215 };
12216
12217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
12218 {
12219 arg1 = (int)(SWIG_As_int(obj0));
12220 if (SWIG_arg_fail(1)) SWIG_fail;
12221 }
12222 {
12223 PyThreadState* __tstate = wxPyBeginAllowThreads();
12224 result = wxLocale::GetLanguageName(arg1);
12225
12226 wxPyEndAllowThreads(__tstate);
12227 if (PyErr_Occurred()) SWIG_fail;
12228 }
12229 {
12230 #if wxUSE_UNICODE
12231 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12232 #else
12233 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12234 #endif
12235 }
12236 return resultobj;
12237 fail:
12238 return NULL;
12239 }
12240
12241
12242 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12243 PyObject *resultobj;
12244 wxString *arg1 = 0 ;
12245 wxLanguageInfo *result;
12246 bool temp1 = false ;
12247 PyObject * obj0 = 0 ;
12248 char *kwnames[] = {
12249 (char *) "locale", NULL
12250 };
12251
12252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
12253 {
12254 arg1 = wxString_in_helper(obj0);
12255 if (arg1 == NULL) SWIG_fail;
12256 temp1 = true;
12257 }
12258 {
12259 PyThreadState* __tstate = wxPyBeginAllowThreads();
12260 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
12261
12262 wxPyEndAllowThreads(__tstate);
12263 if (PyErr_Occurred()) SWIG_fail;
12264 }
12265 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
12266 {
12267 if (temp1)
12268 delete arg1;
12269 }
12270 return resultobj;
12271 fail:
12272 {
12273 if (temp1)
12274 delete arg1;
12275 }
12276 return NULL;
12277 }
12278
12279
12280 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
12281 PyObject *resultobj;
12282 wxLanguageInfo *arg1 = 0 ;
12283 PyObject * obj0 = 0 ;
12284 char *kwnames[] = {
12285 (char *) "info", NULL
12286 };
12287
12288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
12289 {
12290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
12291 if (SWIG_arg_fail(1)) SWIG_fail;
12292 if (arg1 == NULL) {
12293 SWIG_null_ref("wxLanguageInfo");
12294 }
12295 if (SWIG_arg_fail(1)) SWIG_fail;
12296 }
12297 {
12298 PyThreadState* __tstate = wxPyBeginAllowThreads();
12299 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
12300
12301 wxPyEndAllowThreads(__tstate);
12302 if (PyErr_Occurred()) SWIG_fail;
12303 }
12304 Py_INCREF(Py_None); resultobj = Py_None;
12305 return resultobj;
12306 fail:
12307 return NULL;
12308 }
12309
12310
12311 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
12312 PyObject *resultobj;
12313 wxLocale *arg1 = (wxLocale *) 0 ;
12314 wxString *arg2 = 0 ;
12315 wxString const &arg3_defvalue = wxPyEmptyString ;
12316 wxString *arg3 = (wxString *) &arg3_defvalue ;
12317 wxString result;
12318 bool temp2 = false ;
12319 bool temp3 = false ;
12320 PyObject * obj0 = 0 ;
12321 PyObject * obj1 = 0 ;
12322 PyObject * obj2 = 0 ;
12323 char *kwnames[] = {
12324 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
12325 };
12326
12327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
12328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12329 if (SWIG_arg_fail(1)) SWIG_fail;
12330 {
12331 arg2 = wxString_in_helper(obj1);
12332 if (arg2 == NULL) SWIG_fail;
12333 temp2 = true;
12334 }
12335 if (obj2) {
12336 {
12337 arg3 = wxString_in_helper(obj2);
12338 if (arg3 == NULL) SWIG_fail;
12339 temp3 = true;
12340 }
12341 }
12342 {
12343 PyThreadState* __tstate = wxPyBeginAllowThreads();
12344 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
12345
12346 wxPyEndAllowThreads(__tstate);
12347 if (PyErr_Occurred()) SWIG_fail;
12348 }
12349 {
12350 #if wxUSE_UNICODE
12351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12352 #else
12353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12354 #endif
12355 }
12356 {
12357 if (temp2)
12358 delete arg2;
12359 }
12360 {
12361 if (temp3)
12362 delete arg3;
12363 }
12364 return resultobj;
12365 fail:
12366 {
12367 if (temp2)
12368 delete arg2;
12369 }
12370 {
12371 if (temp3)
12372 delete arg3;
12373 }
12374 return NULL;
12375 }
12376
12377
12378 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
12379 PyObject *resultobj;
12380 wxLocale *arg1 = (wxLocale *) 0 ;
12381 wxString *result;
12382 PyObject * obj0 = 0 ;
12383 char *kwnames[] = {
12384 (char *) "self", NULL
12385 };
12386
12387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
12388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12389 if (SWIG_arg_fail(1)) SWIG_fail;
12390 {
12391 PyThreadState* __tstate = wxPyBeginAllowThreads();
12392 {
12393 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
12394 result = (wxString *) &_result_ref;
12395 }
12396
12397 wxPyEndAllowThreads(__tstate);
12398 if (PyErr_Occurred()) SWIG_fail;
12399 }
12400 {
12401 #if wxUSE_UNICODE
12402 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12403 #else
12404 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12405 #endif
12406 }
12407 return resultobj;
12408 fail:
12409 return NULL;
12410 }
12411
12412
12413 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
12414 PyObject *obj;
12415 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12416 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
12417 Py_INCREF(obj);
12418 return Py_BuildValue((char *)"");
12419 }
12420 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
12421 PyObject *resultobj;
12422 wxLocale *result;
12423 char *kwnames[] = {
12424 NULL
12425 };
12426
12427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
12428 {
12429 PyThreadState* __tstate = wxPyBeginAllowThreads();
12430 result = (wxLocale *)wxGetLocale();
12431
12432 wxPyEndAllowThreads(__tstate);
12433 if (PyErr_Occurred()) SWIG_fail;
12434 }
12435 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
12436 return resultobj;
12437 fail:
12438 return NULL;
12439 }
12440
12441
12442 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
12443 PyObject *resultobj;
12444 wxString *arg1 = 0 ;
12445 wxString result;
12446 bool temp1 = false ;
12447 PyObject * obj0 = 0 ;
12448
12449 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
12450 {
12451 arg1 = wxString_in_helper(obj0);
12452 if (arg1 == NULL) SWIG_fail;
12453 temp1 = true;
12454 }
12455 {
12456 PyThreadState* __tstate = wxPyBeginAllowThreads();
12457 result = wxGetTranslation((wxString const &)*arg1);
12458
12459 wxPyEndAllowThreads(__tstate);
12460 if (PyErr_Occurred()) SWIG_fail;
12461 }
12462 {
12463 #if wxUSE_UNICODE
12464 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12465 #else
12466 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12467 #endif
12468 }
12469 {
12470 if (temp1)
12471 delete arg1;
12472 }
12473 return resultobj;
12474 fail:
12475 {
12476 if (temp1)
12477 delete arg1;
12478 }
12479 return NULL;
12480 }
12481
12482
12483 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
12484 PyObject *resultobj;
12485 wxString *arg1 = 0 ;
12486 wxString *arg2 = 0 ;
12487 size_t arg3 ;
12488 wxString result;
12489 bool temp1 = false ;
12490 bool temp2 = false ;
12491 PyObject * obj0 = 0 ;
12492 PyObject * obj1 = 0 ;
12493 PyObject * obj2 = 0 ;
12494
12495 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
12496 {
12497 arg1 = wxString_in_helper(obj0);
12498 if (arg1 == NULL) SWIG_fail;
12499 temp1 = true;
12500 }
12501 {
12502 arg2 = wxString_in_helper(obj1);
12503 if (arg2 == NULL) SWIG_fail;
12504 temp2 = true;
12505 }
12506 {
12507 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
12508 if (SWIG_arg_fail(3)) SWIG_fail;
12509 }
12510 {
12511 PyThreadState* __tstate = wxPyBeginAllowThreads();
12512 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12513
12514 wxPyEndAllowThreads(__tstate);
12515 if (PyErr_Occurred()) SWIG_fail;
12516 }
12517 {
12518 #if wxUSE_UNICODE
12519 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12520 #else
12521 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12522 #endif
12523 }
12524 {
12525 if (temp1)
12526 delete arg1;
12527 }
12528 {
12529 if (temp2)
12530 delete arg2;
12531 }
12532 return resultobj;
12533 fail:
12534 {
12535 if (temp1)
12536 delete arg1;
12537 }
12538 {
12539 if (temp2)
12540 delete arg2;
12541 }
12542 return NULL;
12543 }
12544
12545
12546 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
12547 int argc;
12548 PyObject *argv[4];
12549 int ii;
12550
12551 argc = PyObject_Length(args);
12552 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
12553 argv[ii] = PyTuple_GetItem(args,ii);
12554 }
12555 if (argc == 1) {
12556 int _v;
12557 {
12558 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12559 }
12560 if (_v) {
12561 return _wrap_GetTranslation__SWIG_0(self,args);
12562 }
12563 }
12564 if (argc == 3) {
12565 int _v;
12566 {
12567 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12568 }
12569 if (_v) {
12570 {
12571 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
12572 }
12573 if (_v) {
12574 _v = SWIG_Check_unsigned_SS_long(argv[2]);
12575 if (_v) {
12576 return _wrap_GetTranslation__SWIG_1(self,args);
12577 }
12578 }
12579 }
12580 }
12581
12582 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
12583 return NULL;
12584 }
12585
12586
12587 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12588 PyObject *resultobj;
12589 wxEncodingConverter *result;
12590 char *kwnames[] = {
12591 NULL
12592 };
12593
12594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
12595 {
12596 PyThreadState* __tstate = wxPyBeginAllowThreads();
12597 result = (wxEncodingConverter *)new wxEncodingConverter();
12598
12599 wxPyEndAllowThreads(__tstate);
12600 if (PyErr_Occurred()) SWIG_fail;
12601 }
12602 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
12603 return resultobj;
12604 fail:
12605 return NULL;
12606 }
12607
12608
12609 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12610 PyObject *resultobj;
12611 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12612 PyObject * obj0 = 0 ;
12613 char *kwnames[] = {
12614 (char *) "self", NULL
12615 };
12616
12617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
12618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12619 if (SWIG_arg_fail(1)) SWIG_fail;
12620 {
12621 PyThreadState* __tstate = wxPyBeginAllowThreads();
12622 delete arg1;
12623
12624 wxPyEndAllowThreads(__tstate);
12625 if (PyErr_Occurred()) SWIG_fail;
12626 }
12627 Py_INCREF(Py_None); resultobj = Py_None;
12628 return resultobj;
12629 fail:
12630 return NULL;
12631 }
12632
12633
12634 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
12635 PyObject *resultobj;
12636 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12637 wxFontEncoding arg2 ;
12638 wxFontEncoding arg3 ;
12639 int arg4 = (int) wxCONVERT_STRICT ;
12640 bool result;
12641 PyObject * obj0 = 0 ;
12642 PyObject * obj1 = 0 ;
12643 PyObject * obj2 = 0 ;
12644 PyObject * obj3 = 0 ;
12645 char *kwnames[] = {
12646 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
12647 };
12648
12649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12651 if (SWIG_arg_fail(1)) SWIG_fail;
12652 {
12653 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12654 if (SWIG_arg_fail(2)) SWIG_fail;
12655 }
12656 {
12657 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12658 if (SWIG_arg_fail(3)) SWIG_fail;
12659 }
12660 if (obj3) {
12661 {
12662 arg4 = (int)(SWIG_As_int(obj3));
12663 if (SWIG_arg_fail(4)) SWIG_fail;
12664 }
12665 }
12666 {
12667 PyThreadState* __tstate = wxPyBeginAllowThreads();
12668 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12669
12670 wxPyEndAllowThreads(__tstate);
12671 if (PyErr_Occurred()) SWIG_fail;
12672 }
12673 {
12674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12675 }
12676 return resultobj;
12677 fail:
12678 return NULL;
12679 }
12680
12681
12682 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12683 PyObject *resultobj;
12684 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12685 wxString *arg2 = 0 ;
12686 wxString result;
12687 bool temp2 = false ;
12688 PyObject * obj0 = 0 ;
12689 PyObject * obj1 = 0 ;
12690 char *kwnames[] = {
12691 (char *) "self",(char *) "input", NULL
12692 };
12693
12694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12696 if (SWIG_arg_fail(1)) SWIG_fail;
12697 {
12698 arg2 = wxString_in_helper(obj1);
12699 if (arg2 == NULL) SWIG_fail;
12700 temp2 = true;
12701 }
12702 {
12703 PyThreadState* __tstate = wxPyBeginAllowThreads();
12704 result = (arg1)->Convert((wxString const &)*arg2);
12705
12706 wxPyEndAllowThreads(__tstate);
12707 if (PyErr_Occurred()) SWIG_fail;
12708 }
12709 {
12710 #if wxUSE_UNICODE
12711 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12712 #else
12713 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12714 #endif
12715 }
12716 {
12717 if (temp2)
12718 delete arg2;
12719 }
12720 return resultobj;
12721 fail:
12722 {
12723 if (temp2)
12724 delete arg2;
12725 }
12726 return NULL;
12727 }
12728
12729
12730 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12731 PyObject *resultobj;
12732 wxFontEncoding arg1 ;
12733 int arg2 = (int) wxPLATFORM_CURRENT ;
12734 wxFontEncodingArray result;
12735 PyObject * obj0 = 0 ;
12736 PyObject * obj1 = 0 ;
12737 char *kwnames[] = {
12738 (char *) "enc",(char *) "platform", NULL
12739 };
12740
12741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12742 {
12743 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12744 if (SWIG_arg_fail(1)) SWIG_fail;
12745 }
12746 if (obj1) {
12747 {
12748 arg2 = (int)(SWIG_As_int(obj1));
12749 if (SWIG_arg_fail(2)) SWIG_fail;
12750 }
12751 }
12752 {
12753 PyThreadState* __tstate = wxPyBeginAllowThreads();
12754 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12755
12756 wxPyEndAllowThreads(__tstate);
12757 if (PyErr_Occurred()) SWIG_fail;
12758 }
12759 {
12760 resultobj = PyList_New(0);
12761 for (size_t i=0; i < (&result)->GetCount(); i++) {
12762 PyObject* number = PyInt_FromLong((&result)->Item(i));
12763 PyList_Append(resultobj, number);
12764 Py_DECREF(number);
12765 }
12766 }
12767 return resultobj;
12768 fail:
12769 return NULL;
12770 }
12771
12772
12773 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12774 PyObject *resultobj;
12775 wxFontEncoding arg1 ;
12776 wxFontEncodingArray result;
12777 PyObject * obj0 = 0 ;
12778 char *kwnames[] = {
12779 (char *) "enc", NULL
12780 };
12781
12782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12783 {
12784 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12785 if (SWIG_arg_fail(1)) SWIG_fail;
12786 }
12787 {
12788 PyThreadState* __tstate = wxPyBeginAllowThreads();
12789 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12790
12791 wxPyEndAllowThreads(__tstate);
12792 if (PyErr_Occurred()) SWIG_fail;
12793 }
12794 {
12795 resultobj = PyList_New(0);
12796 for (size_t i=0; i < (&result)->GetCount(); i++) {
12797 PyObject* number = PyInt_FromLong((&result)->Item(i));
12798 PyList_Append(resultobj, number);
12799 Py_DECREF(number);
12800 }
12801 }
12802 return resultobj;
12803 fail:
12804 return NULL;
12805 }
12806
12807
12808 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12809 PyObject *resultobj;
12810 wxFontEncoding arg1 ;
12811 wxFontEncoding arg2 ;
12812 bool result;
12813 PyObject * obj0 = 0 ;
12814 PyObject * obj1 = 0 ;
12815 char *kwnames[] = {
12816 (char *) "encIn",(char *) "encOut", NULL
12817 };
12818
12819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12820 {
12821 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12822 if (SWIG_arg_fail(1)) SWIG_fail;
12823 }
12824 {
12825 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12826 if (SWIG_arg_fail(2)) SWIG_fail;
12827 }
12828 {
12829 PyThreadState* __tstate = wxPyBeginAllowThreads();
12830 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12831
12832 wxPyEndAllowThreads(__tstate);
12833 if (PyErr_Occurred()) SWIG_fail;
12834 }
12835 {
12836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12837 }
12838 return resultobj;
12839 fail:
12840 return NULL;
12841 }
12842
12843
12844 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12845 PyObject *obj;
12846 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12847 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12848 Py_INCREF(obj);
12849 return Py_BuildValue((char *)"");
12850 }
12851 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12852 PyObject *resultobj;
12853 wxDC *arg1 = (wxDC *) 0 ;
12854 PyObject * obj0 = 0 ;
12855 char *kwnames[] = {
12856 (char *) "self", NULL
12857 };
12858
12859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12861 if (SWIG_arg_fail(1)) SWIG_fail;
12862 {
12863 PyThreadState* __tstate = wxPyBeginAllowThreads();
12864 delete arg1;
12865
12866 wxPyEndAllowThreads(__tstate);
12867 if (PyErr_Occurred()) SWIG_fail;
12868 }
12869 Py_INCREF(Py_None); resultobj = Py_None;
12870 return resultobj;
12871 fail:
12872 return NULL;
12873 }
12874
12875
12876 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12877 PyObject *resultobj;
12878 wxDC *arg1 = (wxDC *) 0 ;
12879 PyObject * obj0 = 0 ;
12880 char *kwnames[] = {
12881 (char *) "self", NULL
12882 };
12883
12884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12886 if (SWIG_arg_fail(1)) SWIG_fail;
12887 {
12888 PyThreadState* __tstate = wxPyBeginAllowThreads();
12889 (arg1)->BeginDrawing();
12890
12891 wxPyEndAllowThreads(__tstate);
12892 if (PyErr_Occurred()) SWIG_fail;
12893 }
12894 Py_INCREF(Py_None); resultobj = Py_None;
12895 return resultobj;
12896 fail:
12897 return NULL;
12898 }
12899
12900
12901 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12902 PyObject *resultobj;
12903 wxDC *arg1 = (wxDC *) 0 ;
12904 PyObject * obj0 = 0 ;
12905 char *kwnames[] = {
12906 (char *) "self", NULL
12907 };
12908
12909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12911 if (SWIG_arg_fail(1)) SWIG_fail;
12912 {
12913 PyThreadState* __tstate = wxPyBeginAllowThreads();
12914 (arg1)->EndDrawing();
12915
12916 wxPyEndAllowThreads(__tstate);
12917 if (PyErr_Occurred()) SWIG_fail;
12918 }
12919 Py_INCREF(Py_None); resultobj = Py_None;
12920 return resultobj;
12921 fail:
12922 return NULL;
12923 }
12924
12925
12926 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12927 PyObject *resultobj;
12928 wxDC *arg1 = (wxDC *) 0 ;
12929 int arg2 ;
12930 int arg3 ;
12931 wxColour *arg4 = 0 ;
12932 int arg5 = (int) wxFLOOD_SURFACE ;
12933 bool result;
12934 wxColour temp4 ;
12935 PyObject * obj0 = 0 ;
12936 PyObject * obj1 = 0 ;
12937 PyObject * obj2 = 0 ;
12938 PyObject * obj3 = 0 ;
12939 PyObject * obj4 = 0 ;
12940 char *kwnames[] = {
12941 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12942 };
12943
12944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12946 if (SWIG_arg_fail(1)) SWIG_fail;
12947 {
12948 arg2 = (int)(SWIG_As_int(obj1));
12949 if (SWIG_arg_fail(2)) SWIG_fail;
12950 }
12951 {
12952 arg3 = (int)(SWIG_As_int(obj2));
12953 if (SWIG_arg_fail(3)) SWIG_fail;
12954 }
12955 {
12956 arg4 = &temp4;
12957 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12958 }
12959 if (obj4) {
12960 {
12961 arg5 = (int)(SWIG_As_int(obj4));
12962 if (SWIG_arg_fail(5)) SWIG_fail;
12963 }
12964 }
12965 {
12966 PyThreadState* __tstate = wxPyBeginAllowThreads();
12967 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
12968
12969 wxPyEndAllowThreads(__tstate);
12970 if (PyErr_Occurred()) SWIG_fail;
12971 }
12972 {
12973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12974 }
12975 return resultobj;
12976 fail:
12977 return NULL;
12978 }
12979
12980
12981 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12982 PyObject *resultobj;
12983 wxDC *arg1 = (wxDC *) 0 ;
12984 wxPoint *arg2 = 0 ;
12985 wxColour *arg3 = 0 ;
12986 int arg4 = (int) wxFLOOD_SURFACE ;
12987 bool result;
12988 wxPoint temp2 ;
12989 wxColour temp3 ;
12990 PyObject * obj0 = 0 ;
12991 PyObject * obj1 = 0 ;
12992 PyObject * obj2 = 0 ;
12993 PyObject * obj3 = 0 ;
12994 char *kwnames[] = {
12995 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
12996 };
12997
12998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13000 if (SWIG_arg_fail(1)) SWIG_fail;
13001 {
13002 arg2 = &temp2;
13003 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13004 }
13005 {
13006 arg3 = &temp3;
13007 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
13008 }
13009 if (obj3) {
13010 {
13011 arg4 = (int)(SWIG_As_int(obj3));
13012 if (SWIG_arg_fail(4)) SWIG_fail;
13013 }
13014 }
13015 {
13016 PyThreadState* __tstate = wxPyBeginAllowThreads();
13017 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
13018
13019 wxPyEndAllowThreads(__tstate);
13020 if (PyErr_Occurred()) SWIG_fail;
13021 }
13022 {
13023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13024 }
13025 return resultobj;
13026 fail:
13027 return NULL;
13028 }
13029
13030
13031 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
13032 PyObject *resultobj;
13033 wxDC *arg1 = (wxDC *) 0 ;
13034 int arg2 ;
13035 int arg3 ;
13036 wxColour result;
13037 PyObject * obj0 = 0 ;
13038 PyObject * obj1 = 0 ;
13039 PyObject * obj2 = 0 ;
13040 char *kwnames[] = {
13041 (char *) "self",(char *) "x",(char *) "y", NULL
13042 };
13043
13044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
13045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13046 if (SWIG_arg_fail(1)) SWIG_fail;
13047 {
13048 arg2 = (int)(SWIG_As_int(obj1));
13049 if (SWIG_arg_fail(2)) SWIG_fail;
13050 }
13051 {
13052 arg3 = (int)(SWIG_As_int(obj2));
13053 if (SWIG_arg_fail(3)) SWIG_fail;
13054 }
13055 {
13056 PyThreadState* __tstate = wxPyBeginAllowThreads();
13057 result = wxDC_GetPixel(arg1,arg2,arg3);
13058
13059 wxPyEndAllowThreads(__tstate);
13060 if (PyErr_Occurred()) SWIG_fail;
13061 }
13062 {
13063 wxColour * resultptr;
13064 resultptr = new wxColour((wxColour &)(result));
13065 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13066 }
13067 return resultobj;
13068 fail:
13069 return NULL;
13070 }
13071
13072
13073 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13074 PyObject *resultobj;
13075 wxDC *arg1 = (wxDC *) 0 ;
13076 wxPoint *arg2 = 0 ;
13077 wxColour result;
13078 wxPoint temp2 ;
13079 PyObject * obj0 = 0 ;
13080 PyObject * obj1 = 0 ;
13081 char *kwnames[] = {
13082 (char *) "self",(char *) "pt", NULL
13083 };
13084
13085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
13086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13087 if (SWIG_arg_fail(1)) SWIG_fail;
13088 {
13089 arg2 = &temp2;
13090 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13091 }
13092 {
13093 PyThreadState* __tstate = wxPyBeginAllowThreads();
13094 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
13095
13096 wxPyEndAllowThreads(__tstate);
13097 if (PyErr_Occurred()) SWIG_fail;
13098 }
13099 {
13100 wxColour * resultptr;
13101 resultptr = new wxColour((wxColour &)(result));
13102 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13103 }
13104 return resultobj;
13105 fail:
13106 return NULL;
13107 }
13108
13109
13110 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
13111 PyObject *resultobj;
13112 wxDC *arg1 = (wxDC *) 0 ;
13113 int arg2 ;
13114 int arg3 ;
13115 int arg4 ;
13116 int arg5 ;
13117 PyObject * obj0 = 0 ;
13118 PyObject * obj1 = 0 ;
13119 PyObject * obj2 = 0 ;
13120 PyObject * obj3 = 0 ;
13121 PyObject * obj4 = 0 ;
13122 char *kwnames[] = {
13123 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
13124 };
13125
13126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13128 if (SWIG_arg_fail(1)) SWIG_fail;
13129 {
13130 arg2 = (int)(SWIG_As_int(obj1));
13131 if (SWIG_arg_fail(2)) SWIG_fail;
13132 }
13133 {
13134 arg3 = (int)(SWIG_As_int(obj2));
13135 if (SWIG_arg_fail(3)) SWIG_fail;
13136 }
13137 {
13138 arg4 = (int)(SWIG_As_int(obj3));
13139 if (SWIG_arg_fail(4)) SWIG_fail;
13140 }
13141 {
13142 arg5 = (int)(SWIG_As_int(obj4));
13143 if (SWIG_arg_fail(5)) SWIG_fail;
13144 }
13145 {
13146 PyThreadState* __tstate = wxPyBeginAllowThreads();
13147 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
13148
13149 wxPyEndAllowThreads(__tstate);
13150 if (PyErr_Occurred()) SWIG_fail;
13151 }
13152 Py_INCREF(Py_None); resultobj = Py_None;
13153 return resultobj;
13154 fail:
13155 return NULL;
13156 }
13157
13158
13159 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13160 PyObject *resultobj;
13161 wxDC *arg1 = (wxDC *) 0 ;
13162 wxPoint *arg2 = 0 ;
13163 wxPoint *arg3 = 0 ;
13164 wxPoint temp2 ;
13165 wxPoint temp3 ;
13166 PyObject * obj0 = 0 ;
13167 PyObject * obj1 = 0 ;
13168 PyObject * obj2 = 0 ;
13169 char *kwnames[] = {
13170 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
13171 };
13172
13173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13175 if (SWIG_arg_fail(1)) SWIG_fail;
13176 {
13177 arg2 = &temp2;
13178 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13179 }
13180 {
13181 arg3 = &temp3;
13182 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13183 }
13184 {
13185 PyThreadState* __tstate = wxPyBeginAllowThreads();
13186 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
13187
13188 wxPyEndAllowThreads(__tstate);
13189 if (PyErr_Occurred()) SWIG_fail;
13190 }
13191 Py_INCREF(Py_None); resultobj = Py_None;
13192 return resultobj;
13193 fail:
13194 return NULL;
13195 }
13196
13197
13198 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
13199 PyObject *resultobj;
13200 wxDC *arg1 = (wxDC *) 0 ;
13201 int arg2 ;
13202 int arg3 ;
13203 PyObject * obj0 = 0 ;
13204 PyObject * obj1 = 0 ;
13205 PyObject * obj2 = 0 ;
13206 char *kwnames[] = {
13207 (char *) "self",(char *) "x",(char *) "y", NULL
13208 };
13209
13210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
13211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13212 if (SWIG_arg_fail(1)) SWIG_fail;
13213 {
13214 arg2 = (int)(SWIG_As_int(obj1));
13215 if (SWIG_arg_fail(2)) SWIG_fail;
13216 }
13217 {
13218 arg3 = (int)(SWIG_As_int(obj2));
13219 if (SWIG_arg_fail(3)) SWIG_fail;
13220 }
13221 {
13222 PyThreadState* __tstate = wxPyBeginAllowThreads();
13223 (arg1)->CrossHair(arg2,arg3);
13224
13225 wxPyEndAllowThreads(__tstate);
13226 if (PyErr_Occurred()) SWIG_fail;
13227 }
13228 Py_INCREF(Py_None); resultobj = Py_None;
13229 return resultobj;
13230 fail:
13231 return NULL;
13232 }
13233
13234
13235 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13236 PyObject *resultobj;
13237 wxDC *arg1 = (wxDC *) 0 ;
13238 wxPoint *arg2 = 0 ;
13239 wxPoint temp2 ;
13240 PyObject * obj0 = 0 ;
13241 PyObject * obj1 = 0 ;
13242 char *kwnames[] = {
13243 (char *) "self",(char *) "pt", NULL
13244 };
13245
13246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
13247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13248 if (SWIG_arg_fail(1)) SWIG_fail;
13249 {
13250 arg2 = &temp2;
13251 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13252 }
13253 {
13254 PyThreadState* __tstate = wxPyBeginAllowThreads();
13255 (arg1)->CrossHair((wxPoint const &)*arg2);
13256
13257 wxPyEndAllowThreads(__tstate);
13258 if (PyErr_Occurred()) SWIG_fail;
13259 }
13260 Py_INCREF(Py_None); resultobj = Py_None;
13261 return resultobj;
13262 fail:
13263 return NULL;
13264 }
13265
13266
13267 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
13268 PyObject *resultobj;
13269 wxDC *arg1 = (wxDC *) 0 ;
13270 int arg2 ;
13271 int arg3 ;
13272 int arg4 ;
13273 int arg5 ;
13274 int arg6 ;
13275 int arg7 ;
13276 PyObject * obj0 = 0 ;
13277 PyObject * obj1 = 0 ;
13278 PyObject * obj2 = 0 ;
13279 PyObject * obj3 = 0 ;
13280 PyObject * obj4 = 0 ;
13281 PyObject * obj5 = 0 ;
13282 PyObject * obj6 = 0 ;
13283 char *kwnames[] = {
13284 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
13285 };
13286
13287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) 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 = (int)(SWIG_As_int(obj1));
13292 if (SWIG_arg_fail(2)) SWIG_fail;
13293 }
13294 {
13295 arg3 = (int)(SWIG_As_int(obj2));
13296 if (SWIG_arg_fail(3)) SWIG_fail;
13297 }
13298 {
13299 arg4 = (int)(SWIG_As_int(obj3));
13300 if (SWIG_arg_fail(4)) SWIG_fail;
13301 }
13302 {
13303 arg5 = (int)(SWIG_As_int(obj4));
13304 if (SWIG_arg_fail(5)) SWIG_fail;
13305 }
13306 {
13307 arg6 = (int)(SWIG_As_int(obj5));
13308 if (SWIG_arg_fail(6)) SWIG_fail;
13309 }
13310 {
13311 arg7 = (int)(SWIG_As_int(obj6));
13312 if (SWIG_arg_fail(7)) SWIG_fail;
13313 }
13314 {
13315 PyThreadState* __tstate = wxPyBeginAllowThreads();
13316 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
13317
13318 wxPyEndAllowThreads(__tstate);
13319 if (PyErr_Occurred()) SWIG_fail;
13320 }
13321 Py_INCREF(Py_None); resultobj = Py_None;
13322 return resultobj;
13323 fail:
13324 return NULL;
13325 }
13326
13327
13328 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13329 PyObject *resultobj;
13330 wxDC *arg1 = (wxDC *) 0 ;
13331 wxPoint *arg2 = 0 ;
13332 wxPoint *arg3 = 0 ;
13333 wxPoint *arg4 = 0 ;
13334 wxPoint temp2 ;
13335 wxPoint temp3 ;
13336 wxPoint temp4 ;
13337 PyObject * obj0 = 0 ;
13338 PyObject * obj1 = 0 ;
13339 PyObject * obj2 = 0 ;
13340 PyObject * obj3 = 0 ;
13341 char *kwnames[] = {
13342 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
13343 };
13344
13345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13347 if (SWIG_arg_fail(1)) SWIG_fail;
13348 {
13349 arg2 = &temp2;
13350 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13351 }
13352 {
13353 arg3 = &temp3;
13354 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13355 }
13356 {
13357 arg4 = &temp4;
13358 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
13359 }
13360 {
13361 PyThreadState* __tstate = wxPyBeginAllowThreads();
13362 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
13363
13364 wxPyEndAllowThreads(__tstate);
13365 if (PyErr_Occurred()) SWIG_fail;
13366 }
13367 Py_INCREF(Py_None); resultobj = Py_None;
13368 return resultobj;
13369 fail:
13370 return NULL;
13371 }
13372
13373
13374 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
13375 PyObject *resultobj;
13376 wxDC *arg1 = (wxDC *) 0 ;
13377 int arg2 ;
13378 int arg3 ;
13379 int arg4 ;
13380 int arg5 ;
13381 PyObject * obj0 = 0 ;
13382 PyObject * obj1 = 0 ;
13383 PyObject * obj2 = 0 ;
13384 PyObject * obj3 = 0 ;
13385 PyObject * obj4 = 0 ;
13386 char *kwnames[] = {
13387 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13388 };
13389
13390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13392 if (SWIG_arg_fail(1)) SWIG_fail;
13393 {
13394 arg2 = (int)(SWIG_As_int(obj1));
13395 if (SWIG_arg_fail(2)) SWIG_fail;
13396 }
13397 {
13398 arg3 = (int)(SWIG_As_int(obj2));
13399 if (SWIG_arg_fail(3)) SWIG_fail;
13400 }
13401 {
13402 arg4 = (int)(SWIG_As_int(obj3));
13403 if (SWIG_arg_fail(4)) SWIG_fail;
13404 }
13405 {
13406 arg5 = (int)(SWIG_As_int(obj4));
13407 if (SWIG_arg_fail(5)) SWIG_fail;
13408 }
13409 {
13410 PyThreadState* __tstate = wxPyBeginAllowThreads();
13411 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
13412
13413 wxPyEndAllowThreads(__tstate);
13414 if (PyErr_Occurred()) SWIG_fail;
13415 }
13416 Py_INCREF(Py_None); resultobj = Py_None;
13417 return resultobj;
13418 fail:
13419 return NULL;
13420 }
13421
13422
13423 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
13424 PyObject *resultobj;
13425 wxDC *arg1 = (wxDC *) 0 ;
13426 wxRect *arg2 = 0 ;
13427 wxRect temp2 ;
13428 PyObject * obj0 = 0 ;
13429 PyObject * obj1 = 0 ;
13430 char *kwnames[] = {
13431 (char *) "self",(char *) "rect", NULL
13432 };
13433
13434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
13435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13436 if (SWIG_arg_fail(1)) SWIG_fail;
13437 {
13438 arg2 = &temp2;
13439 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13440 }
13441 {
13442 PyThreadState* __tstate = wxPyBeginAllowThreads();
13443 (arg1)->DrawCheckMark((wxRect const &)*arg2);
13444
13445 wxPyEndAllowThreads(__tstate);
13446 if (PyErr_Occurred()) SWIG_fail;
13447 }
13448 Py_INCREF(Py_None); resultobj = Py_None;
13449 return resultobj;
13450 fail:
13451 return NULL;
13452 }
13453
13454
13455 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
13456 PyObject *resultobj;
13457 wxDC *arg1 = (wxDC *) 0 ;
13458 int arg2 ;
13459 int arg3 ;
13460 int arg4 ;
13461 int arg5 ;
13462 double arg6 ;
13463 double arg7 ;
13464 PyObject * obj0 = 0 ;
13465 PyObject * obj1 = 0 ;
13466 PyObject * obj2 = 0 ;
13467 PyObject * obj3 = 0 ;
13468 PyObject * obj4 = 0 ;
13469 PyObject * obj5 = 0 ;
13470 PyObject * obj6 = 0 ;
13471 char *kwnames[] = {
13472 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
13473 };
13474
13475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13477 if (SWIG_arg_fail(1)) SWIG_fail;
13478 {
13479 arg2 = (int)(SWIG_As_int(obj1));
13480 if (SWIG_arg_fail(2)) SWIG_fail;
13481 }
13482 {
13483 arg3 = (int)(SWIG_As_int(obj2));
13484 if (SWIG_arg_fail(3)) SWIG_fail;
13485 }
13486 {
13487 arg4 = (int)(SWIG_As_int(obj3));
13488 if (SWIG_arg_fail(4)) SWIG_fail;
13489 }
13490 {
13491 arg5 = (int)(SWIG_As_int(obj4));
13492 if (SWIG_arg_fail(5)) SWIG_fail;
13493 }
13494 {
13495 arg6 = (double)(SWIG_As_double(obj5));
13496 if (SWIG_arg_fail(6)) SWIG_fail;
13497 }
13498 {
13499 arg7 = (double)(SWIG_As_double(obj6));
13500 if (SWIG_arg_fail(7)) SWIG_fail;
13501 }
13502 {
13503 PyThreadState* __tstate = wxPyBeginAllowThreads();
13504 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
13505
13506 wxPyEndAllowThreads(__tstate);
13507 if (PyErr_Occurred()) SWIG_fail;
13508 }
13509 Py_INCREF(Py_None); resultobj = Py_None;
13510 return resultobj;
13511 fail:
13512 return NULL;
13513 }
13514
13515
13516 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13517 PyObject *resultobj;
13518 wxDC *arg1 = (wxDC *) 0 ;
13519 wxPoint *arg2 = 0 ;
13520 wxSize *arg3 = 0 ;
13521 double arg4 ;
13522 double arg5 ;
13523 wxPoint temp2 ;
13524 wxSize temp3 ;
13525 PyObject * obj0 = 0 ;
13526 PyObject * obj1 = 0 ;
13527 PyObject * obj2 = 0 ;
13528 PyObject * obj3 = 0 ;
13529 PyObject * obj4 = 0 ;
13530 char *kwnames[] = {
13531 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
13532 };
13533
13534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13536 if (SWIG_arg_fail(1)) SWIG_fail;
13537 {
13538 arg2 = &temp2;
13539 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13540 }
13541 {
13542 arg3 = &temp3;
13543 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13544 }
13545 {
13546 arg4 = (double)(SWIG_As_double(obj3));
13547 if (SWIG_arg_fail(4)) SWIG_fail;
13548 }
13549 {
13550 arg5 = (double)(SWIG_As_double(obj4));
13551 if (SWIG_arg_fail(5)) SWIG_fail;
13552 }
13553 {
13554 PyThreadState* __tstate = wxPyBeginAllowThreads();
13555 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
13556
13557 wxPyEndAllowThreads(__tstate);
13558 if (PyErr_Occurred()) SWIG_fail;
13559 }
13560 Py_INCREF(Py_None); resultobj = Py_None;
13561 return resultobj;
13562 fail:
13563 return NULL;
13564 }
13565
13566
13567 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13568 PyObject *resultobj;
13569 wxDC *arg1 = (wxDC *) 0 ;
13570 int arg2 ;
13571 int arg3 ;
13572 PyObject * obj0 = 0 ;
13573 PyObject * obj1 = 0 ;
13574 PyObject * obj2 = 0 ;
13575 char *kwnames[] = {
13576 (char *) "self",(char *) "x",(char *) "y", NULL
13577 };
13578
13579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13581 if (SWIG_arg_fail(1)) SWIG_fail;
13582 {
13583 arg2 = (int)(SWIG_As_int(obj1));
13584 if (SWIG_arg_fail(2)) SWIG_fail;
13585 }
13586 {
13587 arg3 = (int)(SWIG_As_int(obj2));
13588 if (SWIG_arg_fail(3)) SWIG_fail;
13589 }
13590 {
13591 PyThreadState* __tstate = wxPyBeginAllowThreads();
13592 (arg1)->DrawPoint(arg2,arg3);
13593
13594 wxPyEndAllowThreads(__tstate);
13595 if (PyErr_Occurred()) SWIG_fail;
13596 }
13597 Py_INCREF(Py_None); resultobj = Py_None;
13598 return resultobj;
13599 fail:
13600 return NULL;
13601 }
13602
13603
13604 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13605 PyObject *resultobj;
13606 wxDC *arg1 = (wxDC *) 0 ;
13607 wxPoint *arg2 = 0 ;
13608 wxPoint temp2 ;
13609 PyObject * obj0 = 0 ;
13610 PyObject * obj1 = 0 ;
13611 char *kwnames[] = {
13612 (char *) "self",(char *) "pt", NULL
13613 };
13614
13615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
13616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13617 if (SWIG_arg_fail(1)) SWIG_fail;
13618 {
13619 arg2 = &temp2;
13620 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13621 }
13622 {
13623 PyThreadState* __tstate = wxPyBeginAllowThreads();
13624 (arg1)->DrawPoint((wxPoint const &)*arg2);
13625
13626 wxPyEndAllowThreads(__tstate);
13627 if (PyErr_Occurred()) SWIG_fail;
13628 }
13629 Py_INCREF(Py_None); resultobj = Py_None;
13630 return resultobj;
13631 fail:
13632 return NULL;
13633 }
13634
13635
13636 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13637 PyObject *resultobj;
13638 wxDC *arg1 = (wxDC *) 0 ;
13639 int arg2 ;
13640 int arg3 ;
13641 int arg4 ;
13642 int arg5 ;
13643 PyObject * obj0 = 0 ;
13644 PyObject * obj1 = 0 ;
13645 PyObject * obj2 = 0 ;
13646 PyObject * obj3 = 0 ;
13647 PyObject * obj4 = 0 ;
13648 char *kwnames[] = {
13649 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13650 };
13651
13652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13654 if (SWIG_arg_fail(1)) SWIG_fail;
13655 {
13656 arg2 = (int)(SWIG_As_int(obj1));
13657 if (SWIG_arg_fail(2)) SWIG_fail;
13658 }
13659 {
13660 arg3 = (int)(SWIG_As_int(obj2));
13661 if (SWIG_arg_fail(3)) SWIG_fail;
13662 }
13663 {
13664 arg4 = (int)(SWIG_As_int(obj3));
13665 if (SWIG_arg_fail(4)) SWIG_fail;
13666 }
13667 {
13668 arg5 = (int)(SWIG_As_int(obj4));
13669 if (SWIG_arg_fail(5)) SWIG_fail;
13670 }
13671 {
13672 PyThreadState* __tstate = wxPyBeginAllowThreads();
13673 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13674
13675 wxPyEndAllowThreads(__tstate);
13676 if (PyErr_Occurred()) SWIG_fail;
13677 }
13678 Py_INCREF(Py_None); resultobj = Py_None;
13679 return resultobj;
13680 fail:
13681 return NULL;
13682 }
13683
13684
13685 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13686 PyObject *resultobj;
13687 wxDC *arg1 = (wxDC *) 0 ;
13688 wxRect *arg2 = 0 ;
13689 wxRect temp2 ;
13690 PyObject * obj0 = 0 ;
13691 PyObject * obj1 = 0 ;
13692 char *kwnames[] = {
13693 (char *) "self",(char *) "rect", NULL
13694 };
13695
13696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13698 if (SWIG_arg_fail(1)) SWIG_fail;
13699 {
13700 arg2 = &temp2;
13701 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13702 }
13703 {
13704 PyThreadState* __tstate = wxPyBeginAllowThreads();
13705 (arg1)->DrawRectangle((wxRect const &)*arg2);
13706
13707 wxPyEndAllowThreads(__tstate);
13708 if (PyErr_Occurred()) SWIG_fail;
13709 }
13710 Py_INCREF(Py_None); resultobj = Py_None;
13711 return resultobj;
13712 fail:
13713 return NULL;
13714 }
13715
13716
13717 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13718 PyObject *resultobj;
13719 wxDC *arg1 = (wxDC *) 0 ;
13720 wxPoint *arg2 = 0 ;
13721 wxSize *arg3 = 0 ;
13722 wxPoint temp2 ;
13723 wxSize temp3 ;
13724 PyObject * obj0 = 0 ;
13725 PyObject * obj1 = 0 ;
13726 PyObject * obj2 = 0 ;
13727 char *kwnames[] = {
13728 (char *) "self",(char *) "pt",(char *) "sz", NULL
13729 };
13730
13731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13733 if (SWIG_arg_fail(1)) SWIG_fail;
13734 {
13735 arg2 = &temp2;
13736 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13737 }
13738 {
13739 arg3 = &temp3;
13740 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13741 }
13742 {
13743 PyThreadState* __tstate = wxPyBeginAllowThreads();
13744 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13745
13746 wxPyEndAllowThreads(__tstate);
13747 if (PyErr_Occurred()) SWIG_fail;
13748 }
13749 Py_INCREF(Py_None); resultobj = Py_None;
13750 return resultobj;
13751 fail:
13752 return NULL;
13753 }
13754
13755
13756 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13757 PyObject *resultobj;
13758 wxDC *arg1 = (wxDC *) 0 ;
13759 int arg2 ;
13760 int arg3 ;
13761 int arg4 ;
13762 int arg5 ;
13763 double arg6 ;
13764 PyObject * obj0 = 0 ;
13765 PyObject * obj1 = 0 ;
13766 PyObject * obj2 = 0 ;
13767 PyObject * obj3 = 0 ;
13768 PyObject * obj4 = 0 ;
13769 PyObject * obj5 = 0 ;
13770 char *kwnames[] = {
13771 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13772 };
13773
13774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13776 if (SWIG_arg_fail(1)) SWIG_fail;
13777 {
13778 arg2 = (int)(SWIG_As_int(obj1));
13779 if (SWIG_arg_fail(2)) SWIG_fail;
13780 }
13781 {
13782 arg3 = (int)(SWIG_As_int(obj2));
13783 if (SWIG_arg_fail(3)) SWIG_fail;
13784 }
13785 {
13786 arg4 = (int)(SWIG_As_int(obj3));
13787 if (SWIG_arg_fail(4)) SWIG_fail;
13788 }
13789 {
13790 arg5 = (int)(SWIG_As_int(obj4));
13791 if (SWIG_arg_fail(5)) SWIG_fail;
13792 }
13793 {
13794 arg6 = (double)(SWIG_As_double(obj5));
13795 if (SWIG_arg_fail(6)) SWIG_fail;
13796 }
13797 {
13798 PyThreadState* __tstate = wxPyBeginAllowThreads();
13799 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13800
13801 wxPyEndAllowThreads(__tstate);
13802 if (PyErr_Occurred()) SWIG_fail;
13803 }
13804 Py_INCREF(Py_None); resultobj = Py_None;
13805 return resultobj;
13806 fail:
13807 return NULL;
13808 }
13809
13810
13811 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13812 PyObject *resultobj;
13813 wxDC *arg1 = (wxDC *) 0 ;
13814 wxRect *arg2 = 0 ;
13815 double arg3 ;
13816 wxRect temp2 ;
13817 PyObject * obj0 = 0 ;
13818 PyObject * obj1 = 0 ;
13819 PyObject * obj2 = 0 ;
13820 char *kwnames[] = {
13821 (char *) "self",(char *) "r",(char *) "radius", NULL
13822 };
13823
13824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13826 if (SWIG_arg_fail(1)) SWIG_fail;
13827 {
13828 arg2 = &temp2;
13829 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13830 }
13831 {
13832 arg3 = (double)(SWIG_As_double(obj2));
13833 if (SWIG_arg_fail(3)) SWIG_fail;
13834 }
13835 {
13836 PyThreadState* __tstate = wxPyBeginAllowThreads();
13837 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13838
13839 wxPyEndAllowThreads(__tstate);
13840 if (PyErr_Occurred()) SWIG_fail;
13841 }
13842 Py_INCREF(Py_None); resultobj = Py_None;
13843 return resultobj;
13844 fail:
13845 return NULL;
13846 }
13847
13848
13849 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13850 PyObject *resultobj;
13851 wxDC *arg1 = (wxDC *) 0 ;
13852 wxPoint *arg2 = 0 ;
13853 wxSize *arg3 = 0 ;
13854 double arg4 ;
13855 wxPoint temp2 ;
13856 wxSize temp3 ;
13857 PyObject * obj0 = 0 ;
13858 PyObject * obj1 = 0 ;
13859 PyObject * obj2 = 0 ;
13860 PyObject * obj3 = 0 ;
13861 char *kwnames[] = {
13862 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13863 };
13864
13865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13867 if (SWIG_arg_fail(1)) SWIG_fail;
13868 {
13869 arg2 = &temp2;
13870 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13871 }
13872 {
13873 arg3 = &temp3;
13874 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13875 }
13876 {
13877 arg4 = (double)(SWIG_As_double(obj3));
13878 if (SWIG_arg_fail(4)) SWIG_fail;
13879 }
13880 {
13881 PyThreadState* __tstate = wxPyBeginAllowThreads();
13882 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13883
13884 wxPyEndAllowThreads(__tstate);
13885 if (PyErr_Occurred()) SWIG_fail;
13886 }
13887 Py_INCREF(Py_None); resultobj = Py_None;
13888 return resultobj;
13889 fail:
13890 return NULL;
13891 }
13892
13893
13894 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13895 PyObject *resultobj;
13896 wxDC *arg1 = (wxDC *) 0 ;
13897 int arg2 ;
13898 int arg3 ;
13899 int arg4 ;
13900 PyObject * obj0 = 0 ;
13901 PyObject * obj1 = 0 ;
13902 PyObject * obj2 = 0 ;
13903 PyObject * obj3 = 0 ;
13904 char *kwnames[] = {
13905 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13906 };
13907
13908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13910 if (SWIG_arg_fail(1)) SWIG_fail;
13911 {
13912 arg2 = (int)(SWIG_As_int(obj1));
13913 if (SWIG_arg_fail(2)) SWIG_fail;
13914 }
13915 {
13916 arg3 = (int)(SWIG_As_int(obj2));
13917 if (SWIG_arg_fail(3)) SWIG_fail;
13918 }
13919 {
13920 arg4 = (int)(SWIG_As_int(obj3));
13921 if (SWIG_arg_fail(4)) SWIG_fail;
13922 }
13923 {
13924 PyThreadState* __tstate = wxPyBeginAllowThreads();
13925 (arg1)->DrawCircle(arg2,arg3,arg4);
13926
13927 wxPyEndAllowThreads(__tstate);
13928 if (PyErr_Occurred()) SWIG_fail;
13929 }
13930 Py_INCREF(Py_None); resultobj = Py_None;
13931 return resultobj;
13932 fail:
13933 return NULL;
13934 }
13935
13936
13937 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13938 PyObject *resultobj;
13939 wxDC *arg1 = (wxDC *) 0 ;
13940 wxPoint *arg2 = 0 ;
13941 int arg3 ;
13942 wxPoint temp2 ;
13943 PyObject * obj0 = 0 ;
13944 PyObject * obj1 = 0 ;
13945 PyObject * obj2 = 0 ;
13946 char *kwnames[] = {
13947 (char *) "self",(char *) "pt",(char *) "radius", NULL
13948 };
13949
13950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13952 if (SWIG_arg_fail(1)) SWIG_fail;
13953 {
13954 arg2 = &temp2;
13955 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13956 }
13957 {
13958 arg3 = (int)(SWIG_As_int(obj2));
13959 if (SWIG_arg_fail(3)) SWIG_fail;
13960 }
13961 {
13962 PyThreadState* __tstate = wxPyBeginAllowThreads();
13963 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13964
13965 wxPyEndAllowThreads(__tstate);
13966 if (PyErr_Occurred()) SWIG_fail;
13967 }
13968 Py_INCREF(Py_None); resultobj = Py_None;
13969 return resultobj;
13970 fail:
13971 return NULL;
13972 }
13973
13974
13975 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
13976 PyObject *resultobj;
13977 wxDC *arg1 = (wxDC *) 0 ;
13978 int arg2 ;
13979 int arg3 ;
13980 int arg4 ;
13981 int arg5 ;
13982 PyObject * obj0 = 0 ;
13983 PyObject * obj1 = 0 ;
13984 PyObject * obj2 = 0 ;
13985 PyObject * obj3 = 0 ;
13986 PyObject * obj4 = 0 ;
13987 char *kwnames[] = {
13988 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13989 };
13990
13991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13993 if (SWIG_arg_fail(1)) SWIG_fail;
13994 {
13995 arg2 = (int)(SWIG_As_int(obj1));
13996 if (SWIG_arg_fail(2)) SWIG_fail;
13997 }
13998 {
13999 arg3 = (int)(SWIG_As_int(obj2));
14000 if (SWIG_arg_fail(3)) SWIG_fail;
14001 }
14002 {
14003 arg4 = (int)(SWIG_As_int(obj3));
14004 if (SWIG_arg_fail(4)) SWIG_fail;
14005 }
14006 {
14007 arg5 = (int)(SWIG_As_int(obj4));
14008 if (SWIG_arg_fail(5)) SWIG_fail;
14009 }
14010 {
14011 PyThreadState* __tstate = wxPyBeginAllowThreads();
14012 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
14013
14014 wxPyEndAllowThreads(__tstate);
14015 if (PyErr_Occurred()) SWIG_fail;
14016 }
14017 Py_INCREF(Py_None); resultobj = Py_None;
14018 return resultobj;
14019 fail:
14020 return NULL;
14021 }
14022
14023
14024 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
14025 PyObject *resultobj;
14026 wxDC *arg1 = (wxDC *) 0 ;
14027 wxRect *arg2 = 0 ;
14028 wxRect temp2 ;
14029 PyObject * obj0 = 0 ;
14030 PyObject * obj1 = 0 ;
14031 char *kwnames[] = {
14032 (char *) "self",(char *) "rect", NULL
14033 };
14034
14035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
14036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14037 if (SWIG_arg_fail(1)) SWIG_fail;
14038 {
14039 arg2 = &temp2;
14040 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14041 }
14042 {
14043 PyThreadState* __tstate = wxPyBeginAllowThreads();
14044 (arg1)->DrawEllipse((wxRect const &)*arg2);
14045
14046 wxPyEndAllowThreads(__tstate);
14047 if (PyErr_Occurred()) SWIG_fail;
14048 }
14049 Py_INCREF(Py_None); resultobj = Py_None;
14050 return resultobj;
14051 fail:
14052 return NULL;
14053 }
14054
14055
14056 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14057 PyObject *resultobj;
14058 wxDC *arg1 = (wxDC *) 0 ;
14059 wxPoint *arg2 = 0 ;
14060 wxSize *arg3 = 0 ;
14061 wxPoint temp2 ;
14062 wxSize temp3 ;
14063 PyObject * obj0 = 0 ;
14064 PyObject * obj1 = 0 ;
14065 PyObject * obj2 = 0 ;
14066 char *kwnames[] = {
14067 (char *) "self",(char *) "pt",(char *) "sz", NULL
14068 };
14069
14070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14072 if (SWIG_arg_fail(1)) SWIG_fail;
14073 {
14074 arg2 = &temp2;
14075 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14076 }
14077 {
14078 arg3 = &temp3;
14079 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14080 }
14081 {
14082 PyThreadState* __tstate = wxPyBeginAllowThreads();
14083 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
14084
14085 wxPyEndAllowThreads(__tstate);
14086 if (PyErr_Occurred()) SWIG_fail;
14087 }
14088 Py_INCREF(Py_None); resultobj = Py_None;
14089 return resultobj;
14090 fail:
14091 return NULL;
14092 }
14093
14094
14095 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14096 PyObject *resultobj;
14097 wxDC *arg1 = (wxDC *) 0 ;
14098 wxIcon *arg2 = 0 ;
14099 int arg3 ;
14100 int arg4 ;
14101 PyObject * obj0 = 0 ;
14102 PyObject * obj1 = 0 ;
14103 PyObject * obj2 = 0 ;
14104 PyObject * obj3 = 0 ;
14105 char *kwnames[] = {
14106 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
14107 };
14108
14109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14111 if (SWIG_arg_fail(1)) SWIG_fail;
14112 {
14113 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
14114 if (SWIG_arg_fail(2)) SWIG_fail;
14115 if (arg2 == NULL) {
14116 SWIG_null_ref("wxIcon");
14117 }
14118 if (SWIG_arg_fail(2)) SWIG_fail;
14119 }
14120 {
14121 arg3 = (int)(SWIG_As_int(obj2));
14122 if (SWIG_arg_fail(3)) SWIG_fail;
14123 }
14124 {
14125 arg4 = (int)(SWIG_As_int(obj3));
14126 if (SWIG_arg_fail(4)) SWIG_fail;
14127 }
14128 {
14129 PyThreadState* __tstate = wxPyBeginAllowThreads();
14130 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
14131
14132 wxPyEndAllowThreads(__tstate);
14133 if (PyErr_Occurred()) SWIG_fail;
14134 }
14135 Py_INCREF(Py_None); resultobj = Py_None;
14136 return resultobj;
14137 fail:
14138 return NULL;
14139 }
14140
14141
14142 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14143 PyObject *resultobj;
14144 wxDC *arg1 = (wxDC *) 0 ;
14145 wxIcon *arg2 = 0 ;
14146 wxPoint *arg3 = 0 ;
14147 wxPoint temp3 ;
14148 PyObject * obj0 = 0 ;
14149 PyObject * obj1 = 0 ;
14150 PyObject * obj2 = 0 ;
14151 char *kwnames[] = {
14152 (char *) "self",(char *) "icon",(char *) "pt", NULL
14153 };
14154
14155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
14156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14157 if (SWIG_arg_fail(1)) SWIG_fail;
14158 {
14159 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
14160 if (SWIG_arg_fail(2)) SWIG_fail;
14161 if (arg2 == NULL) {
14162 SWIG_null_ref("wxIcon");
14163 }
14164 if (SWIG_arg_fail(2)) SWIG_fail;
14165 }
14166 {
14167 arg3 = &temp3;
14168 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14169 }
14170 {
14171 PyThreadState* __tstate = wxPyBeginAllowThreads();
14172 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
14173
14174 wxPyEndAllowThreads(__tstate);
14175 if (PyErr_Occurred()) SWIG_fail;
14176 }
14177 Py_INCREF(Py_None); resultobj = Py_None;
14178 return resultobj;
14179 fail:
14180 return NULL;
14181 }
14182
14183
14184 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14185 PyObject *resultobj;
14186 wxDC *arg1 = (wxDC *) 0 ;
14187 wxBitmap *arg2 = 0 ;
14188 int arg3 ;
14189 int arg4 ;
14190 bool arg5 = (bool) false ;
14191 PyObject * obj0 = 0 ;
14192 PyObject * obj1 = 0 ;
14193 PyObject * obj2 = 0 ;
14194 PyObject * obj3 = 0 ;
14195 PyObject * obj4 = 0 ;
14196 char *kwnames[] = {
14197 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
14198 };
14199
14200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14202 if (SWIG_arg_fail(1)) SWIG_fail;
14203 {
14204 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14205 if (SWIG_arg_fail(2)) SWIG_fail;
14206 if (arg2 == NULL) {
14207 SWIG_null_ref("wxBitmap");
14208 }
14209 if (SWIG_arg_fail(2)) SWIG_fail;
14210 }
14211 {
14212 arg3 = (int)(SWIG_As_int(obj2));
14213 if (SWIG_arg_fail(3)) SWIG_fail;
14214 }
14215 {
14216 arg4 = (int)(SWIG_As_int(obj3));
14217 if (SWIG_arg_fail(4)) SWIG_fail;
14218 }
14219 if (obj4) {
14220 {
14221 arg5 = (bool)(SWIG_As_bool(obj4));
14222 if (SWIG_arg_fail(5)) SWIG_fail;
14223 }
14224 }
14225 {
14226 PyThreadState* __tstate = wxPyBeginAllowThreads();
14227 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
14228
14229 wxPyEndAllowThreads(__tstate);
14230 if (PyErr_Occurred()) SWIG_fail;
14231 }
14232 Py_INCREF(Py_None); resultobj = Py_None;
14233 return resultobj;
14234 fail:
14235 return NULL;
14236 }
14237
14238
14239 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14240 PyObject *resultobj;
14241 wxDC *arg1 = (wxDC *) 0 ;
14242 wxBitmap *arg2 = 0 ;
14243 wxPoint *arg3 = 0 ;
14244 bool arg4 = (bool) false ;
14245 wxPoint temp3 ;
14246 PyObject * obj0 = 0 ;
14247 PyObject * obj1 = 0 ;
14248 PyObject * obj2 = 0 ;
14249 PyObject * obj3 = 0 ;
14250 char *kwnames[] = {
14251 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
14252 };
14253
14254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14256 if (SWIG_arg_fail(1)) SWIG_fail;
14257 {
14258 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14259 if (SWIG_arg_fail(2)) SWIG_fail;
14260 if (arg2 == NULL) {
14261 SWIG_null_ref("wxBitmap");
14262 }
14263 if (SWIG_arg_fail(2)) SWIG_fail;
14264 }
14265 {
14266 arg3 = &temp3;
14267 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14268 }
14269 if (obj3) {
14270 {
14271 arg4 = (bool)(SWIG_As_bool(obj3));
14272 if (SWIG_arg_fail(4)) SWIG_fail;
14273 }
14274 }
14275 {
14276 PyThreadState* __tstate = wxPyBeginAllowThreads();
14277 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
14278
14279 wxPyEndAllowThreads(__tstate);
14280 if (PyErr_Occurred()) SWIG_fail;
14281 }
14282 Py_INCREF(Py_None); resultobj = Py_None;
14283 return resultobj;
14284 fail:
14285 return NULL;
14286 }
14287
14288
14289 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
14290 PyObject *resultobj;
14291 wxDC *arg1 = (wxDC *) 0 ;
14292 wxString *arg2 = 0 ;
14293 int arg3 ;
14294 int arg4 ;
14295 bool temp2 = false ;
14296 PyObject * obj0 = 0 ;
14297 PyObject * obj1 = 0 ;
14298 PyObject * obj2 = 0 ;
14299 PyObject * obj3 = 0 ;
14300 char *kwnames[] = {
14301 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
14302 };
14303
14304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14306 if (SWIG_arg_fail(1)) SWIG_fail;
14307 {
14308 arg2 = wxString_in_helper(obj1);
14309 if (arg2 == NULL) SWIG_fail;
14310 temp2 = true;
14311 }
14312 {
14313 arg3 = (int)(SWIG_As_int(obj2));
14314 if (SWIG_arg_fail(3)) SWIG_fail;
14315 }
14316 {
14317 arg4 = (int)(SWIG_As_int(obj3));
14318 if (SWIG_arg_fail(4)) SWIG_fail;
14319 }
14320 {
14321 PyThreadState* __tstate = wxPyBeginAllowThreads();
14322 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
14323
14324 wxPyEndAllowThreads(__tstate);
14325 if (PyErr_Occurred()) SWIG_fail;
14326 }
14327 Py_INCREF(Py_None); resultobj = Py_None;
14328 {
14329 if (temp2)
14330 delete arg2;
14331 }
14332 return resultobj;
14333 fail:
14334 {
14335 if (temp2)
14336 delete arg2;
14337 }
14338 return NULL;
14339 }
14340
14341
14342 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14343 PyObject *resultobj;
14344 wxDC *arg1 = (wxDC *) 0 ;
14345 wxString *arg2 = 0 ;
14346 wxPoint *arg3 = 0 ;
14347 bool temp2 = false ;
14348 wxPoint temp3 ;
14349 PyObject * obj0 = 0 ;
14350 PyObject * obj1 = 0 ;
14351 PyObject * obj2 = 0 ;
14352 char *kwnames[] = {
14353 (char *) "self",(char *) "text",(char *) "pt", NULL
14354 };
14355
14356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
14357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14358 if (SWIG_arg_fail(1)) SWIG_fail;
14359 {
14360 arg2 = wxString_in_helper(obj1);
14361 if (arg2 == NULL) SWIG_fail;
14362 temp2 = true;
14363 }
14364 {
14365 arg3 = &temp3;
14366 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14367 }
14368 {
14369 PyThreadState* __tstate = wxPyBeginAllowThreads();
14370 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
14371
14372 wxPyEndAllowThreads(__tstate);
14373 if (PyErr_Occurred()) SWIG_fail;
14374 }
14375 Py_INCREF(Py_None); resultobj = Py_None;
14376 {
14377 if (temp2)
14378 delete arg2;
14379 }
14380 return resultobj;
14381 fail:
14382 {
14383 if (temp2)
14384 delete arg2;
14385 }
14386 return NULL;
14387 }
14388
14389
14390 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
14391 PyObject *resultobj;
14392 wxDC *arg1 = (wxDC *) 0 ;
14393 wxString *arg2 = 0 ;
14394 int arg3 ;
14395 int arg4 ;
14396 double arg5 ;
14397 bool temp2 = false ;
14398 PyObject * obj0 = 0 ;
14399 PyObject * obj1 = 0 ;
14400 PyObject * obj2 = 0 ;
14401 PyObject * obj3 = 0 ;
14402 PyObject * obj4 = 0 ;
14403 char *kwnames[] = {
14404 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
14405 };
14406
14407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14409 if (SWIG_arg_fail(1)) SWIG_fail;
14410 {
14411 arg2 = wxString_in_helper(obj1);
14412 if (arg2 == NULL) SWIG_fail;
14413 temp2 = true;
14414 }
14415 {
14416 arg3 = (int)(SWIG_As_int(obj2));
14417 if (SWIG_arg_fail(3)) SWIG_fail;
14418 }
14419 {
14420 arg4 = (int)(SWIG_As_int(obj3));
14421 if (SWIG_arg_fail(4)) SWIG_fail;
14422 }
14423 {
14424 arg5 = (double)(SWIG_As_double(obj4));
14425 if (SWIG_arg_fail(5)) SWIG_fail;
14426 }
14427 {
14428 PyThreadState* __tstate = wxPyBeginAllowThreads();
14429 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
14430
14431 wxPyEndAllowThreads(__tstate);
14432 if (PyErr_Occurred()) SWIG_fail;
14433 }
14434 Py_INCREF(Py_None); resultobj = Py_None;
14435 {
14436 if (temp2)
14437 delete arg2;
14438 }
14439 return resultobj;
14440 fail:
14441 {
14442 if (temp2)
14443 delete arg2;
14444 }
14445 return NULL;
14446 }
14447
14448
14449 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14450 PyObject *resultobj;
14451 wxDC *arg1 = (wxDC *) 0 ;
14452 wxString *arg2 = 0 ;
14453 wxPoint *arg3 = 0 ;
14454 double arg4 ;
14455 bool temp2 = false ;
14456 wxPoint temp3 ;
14457 PyObject * obj0 = 0 ;
14458 PyObject * obj1 = 0 ;
14459 PyObject * obj2 = 0 ;
14460 PyObject * obj3 = 0 ;
14461 char *kwnames[] = {
14462 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
14463 };
14464
14465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14467 if (SWIG_arg_fail(1)) SWIG_fail;
14468 {
14469 arg2 = wxString_in_helper(obj1);
14470 if (arg2 == NULL) SWIG_fail;
14471 temp2 = true;
14472 }
14473 {
14474 arg3 = &temp3;
14475 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14476 }
14477 {
14478 arg4 = (double)(SWIG_As_double(obj3));
14479 if (SWIG_arg_fail(4)) SWIG_fail;
14480 }
14481 {
14482 PyThreadState* __tstate = wxPyBeginAllowThreads();
14483 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
14484
14485 wxPyEndAllowThreads(__tstate);
14486 if (PyErr_Occurred()) SWIG_fail;
14487 }
14488 Py_INCREF(Py_None); resultobj = Py_None;
14489 {
14490 if (temp2)
14491 delete arg2;
14492 }
14493 return resultobj;
14494 fail:
14495 {
14496 if (temp2)
14497 delete arg2;
14498 }
14499 return NULL;
14500 }
14501
14502
14503 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
14504 PyObject *resultobj;
14505 wxDC *arg1 = (wxDC *) 0 ;
14506 int arg2 ;
14507 int arg3 ;
14508 int arg4 ;
14509 int arg5 ;
14510 wxDC *arg6 = (wxDC *) 0 ;
14511 int arg7 ;
14512 int arg8 ;
14513 int arg9 = (int) wxCOPY ;
14514 bool arg10 = (bool) false ;
14515 int arg11 = (int) -1 ;
14516 int arg12 = (int) -1 ;
14517 bool result;
14518 PyObject * obj0 = 0 ;
14519 PyObject * obj1 = 0 ;
14520 PyObject * obj2 = 0 ;
14521 PyObject * obj3 = 0 ;
14522 PyObject * obj4 = 0 ;
14523 PyObject * obj5 = 0 ;
14524 PyObject * obj6 = 0 ;
14525 PyObject * obj7 = 0 ;
14526 PyObject * obj8 = 0 ;
14527 PyObject * obj9 = 0 ;
14528 PyObject * obj10 = 0 ;
14529 PyObject * obj11 = 0 ;
14530 char *kwnames[] = {
14531 (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
14532 };
14533
14534 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;
14535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14536 if (SWIG_arg_fail(1)) SWIG_fail;
14537 {
14538 arg2 = (int)(SWIG_As_int(obj1));
14539 if (SWIG_arg_fail(2)) SWIG_fail;
14540 }
14541 {
14542 arg3 = (int)(SWIG_As_int(obj2));
14543 if (SWIG_arg_fail(3)) SWIG_fail;
14544 }
14545 {
14546 arg4 = (int)(SWIG_As_int(obj3));
14547 if (SWIG_arg_fail(4)) SWIG_fail;
14548 }
14549 {
14550 arg5 = (int)(SWIG_As_int(obj4));
14551 if (SWIG_arg_fail(5)) SWIG_fail;
14552 }
14553 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14554 if (SWIG_arg_fail(6)) SWIG_fail;
14555 {
14556 arg7 = (int)(SWIG_As_int(obj6));
14557 if (SWIG_arg_fail(7)) SWIG_fail;
14558 }
14559 {
14560 arg8 = (int)(SWIG_As_int(obj7));
14561 if (SWIG_arg_fail(8)) SWIG_fail;
14562 }
14563 if (obj8) {
14564 {
14565 arg9 = (int)(SWIG_As_int(obj8));
14566 if (SWIG_arg_fail(9)) SWIG_fail;
14567 }
14568 }
14569 if (obj9) {
14570 {
14571 arg10 = (bool)(SWIG_As_bool(obj9));
14572 if (SWIG_arg_fail(10)) SWIG_fail;
14573 }
14574 }
14575 if (obj10) {
14576 {
14577 arg11 = (int)(SWIG_As_int(obj10));
14578 if (SWIG_arg_fail(11)) SWIG_fail;
14579 }
14580 }
14581 if (obj11) {
14582 {
14583 arg12 = (int)(SWIG_As_int(obj11));
14584 if (SWIG_arg_fail(12)) SWIG_fail;
14585 }
14586 }
14587 {
14588 PyThreadState* __tstate = wxPyBeginAllowThreads();
14589 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14590
14591 wxPyEndAllowThreads(__tstate);
14592 if (PyErr_Occurred()) SWIG_fail;
14593 }
14594 {
14595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14596 }
14597 return resultobj;
14598 fail:
14599 return NULL;
14600 }
14601
14602
14603 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14604 PyObject *resultobj;
14605 wxDC *arg1 = (wxDC *) 0 ;
14606 wxPoint *arg2 = 0 ;
14607 wxSize *arg3 = 0 ;
14608 wxDC *arg4 = (wxDC *) 0 ;
14609 wxPoint *arg5 = 0 ;
14610 int arg6 = (int) wxCOPY ;
14611 bool arg7 = (bool) false ;
14612 wxPoint const &arg8_defvalue = wxDefaultPosition ;
14613 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
14614 bool result;
14615 wxPoint temp2 ;
14616 wxSize temp3 ;
14617 wxPoint temp5 ;
14618 wxPoint temp8 ;
14619 PyObject * obj0 = 0 ;
14620 PyObject * obj1 = 0 ;
14621 PyObject * obj2 = 0 ;
14622 PyObject * obj3 = 0 ;
14623 PyObject * obj4 = 0 ;
14624 PyObject * obj5 = 0 ;
14625 PyObject * obj6 = 0 ;
14626 PyObject * obj7 = 0 ;
14627 char *kwnames[] = {
14628 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
14629 };
14630
14631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
14632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14633 if (SWIG_arg_fail(1)) SWIG_fail;
14634 {
14635 arg2 = &temp2;
14636 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14637 }
14638 {
14639 arg3 = &temp3;
14640 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14641 }
14642 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14643 if (SWIG_arg_fail(4)) SWIG_fail;
14644 {
14645 arg5 = &temp5;
14646 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14647 }
14648 if (obj5) {
14649 {
14650 arg6 = (int)(SWIG_As_int(obj5));
14651 if (SWIG_arg_fail(6)) SWIG_fail;
14652 }
14653 }
14654 if (obj6) {
14655 {
14656 arg7 = (bool)(SWIG_As_bool(obj6));
14657 if (SWIG_arg_fail(7)) SWIG_fail;
14658 }
14659 }
14660 if (obj7) {
14661 {
14662 arg8 = &temp8;
14663 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14664 }
14665 }
14666 {
14667 PyThreadState* __tstate = wxPyBeginAllowThreads();
14668 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14669
14670 wxPyEndAllowThreads(__tstate);
14671 if (PyErr_Occurred()) SWIG_fail;
14672 }
14673 {
14674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14675 }
14676 return resultobj;
14677 fail:
14678 return NULL;
14679 }
14680
14681
14682 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14683 PyObject *resultobj;
14684 wxDC *arg1 = (wxDC *) 0 ;
14685 int arg2 ;
14686 int arg3 ;
14687 int arg4 ;
14688 int arg5 ;
14689 PyObject * obj0 = 0 ;
14690 PyObject * obj1 = 0 ;
14691 PyObject * obj2 = 0 ;
14692 PyObject * obj3 = 0 ;
14693 PyObject * obj4 = 0 ;
14694 char *kwnames[] = {
14695 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14696 };
14697
14698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14700 if (SWIG_arg_fail(1)) SWIG_fail;
14701 {
14702 arg2 = (int)(SWIG_As_int(obj1));
14703 if (SWIG_arg_fail(2)) SWIG_fail;
14704 }
14705 {
14706 arg3 = (int)(SWIG_As_int(obj2));
14707 if (SWIG_arg_fail(3)) SWIG_fail;
14708 }
14709 {
14710 arg4 = (int)(SWIG_As_int(obj3));
14711 if (SWIG_arg_fail(4)) SWIG_fail;
14712 }
14713 {
14714 arg5 = (int)(SWIG_As_int(obj4));
14715 if (SWIG_arg_fail(5)) SWIG_fail;
14716 }
14717 {
14718 PyThreadState* __tstate = wxPyBeginAllowThreads();
14719 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14720
14721 wxPyEndAllowThreads(__tstate);
14722 if (PyErr_Occurred()) SWIG_fail;
14723 }
14724 Py_INCREF(Py_None); resultobj = Py_None;
14725 return resultobj;
14726 fail:
14727 return NULL;
14728 }
14729
14730
14731 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14732 PyObject *resultobj;
14733 wxDC *arg1 = (wxDC *) 0 ;
14734 wxPoint *arg2 = 0 ;
14735 wxSize *arg3 = 0 ;
14736 wxPoint temp2 ;
14737 wxSize temp3 ;
14738 PyObject * obj0 = 0 ;
14739 PyObject * obj1 = 0 ;
14740 PyObject * obj2 = 0 ;
14741 char *kwnames[] = {
14742 (char *) "self",(char *) "pt",(char *) "sz", NULL
14743 };
14744
14745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14747 if (SWIG_arg_fail(1)) SWIG_fail;
14748 {
14749 arg2 = &temp2;
14750 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14751 }
14752 {
14753 arg3 = &temp3;
14754 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14755 }
14756 {
14757 PyThreadState* __tstate = wxPyBeginAllowThreads();
14758 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14759
14760 wxPyEndAllowThreads(__tstate);
14761 if (PyErr_Occurred()) SWIG_fail;
14762 }
14763 Py_INCREF(Py_None); resultobj = Py_None;
14764 return resultobj;
14765 fail:
14766 return NULL;
14767 }
14768
14769
14770 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14771 PyObject *resultobj;
14772 wxDC *arg1 = (wxDC *) 0 ;
14773 wxRegion *arg2 = 0 ;
14774 PyObject * obj0 = 0 ;
14775 PyObject * obj1 = 0 ;
14776 char *kwnames[] = {
14777 (char *) "self",(char *) "region", NULL
14778 };
14779
14780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14782 if (SWIG_arg_fail(1)) SWIG_fail;
14783 {
14784 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14785 if (SWIG_arg_fail(2)) SWIG_fail;
14786 if (arg2 == NULL) {
14787 SWIG_null_ref("wxRegion");
14788 }
14789 if (SWIG_arg_fail(2)) SWIG_fail;
14790 }
14791 {
14792 PyThreadState* __tstate = wxPyBeginAllowThreads();
14793 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14794
14795 wxPyEndAllowThreads(__tstate);
14796 if (PyErr_Occurred()) SWIG_fail;
14797 }
14798 Py_INCREF(Py_None); resultobj = Py_None;
14799 return resultobj;
14800 fail:
14801 return NULL;
14802 }
14803
14804
14805 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14806 PyObject *resultobj;
14807 wxDC *arg1 = (wxDC *) 0 ;
14808 wxRect *arg2 = 0 ;
14809 wxRect temp2 ;
14810 PyObject * obj0 = 0 ;
14811 PyObject * obj1 = 0 ;
14812 char *kwnames[] = {
14813 (char *) "self",(char *) "rect", NULL
14814 };
14815
14816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14818 if (SWIG_arg_fail(1)) SWIG_fail;
14819 {
14820 arg2 = &temp2;
14821 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14822 }
14823 {
14824 PyThreadState* __tstate = wxPyBeginAllowThreads();
14825 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14826
14827 wxPyEndAllowThreads(__tstate);
14828 if (PyErr_Occurred()) SWIG_fail;
14829 }
14830 Py_INCREF(Py_None); resultobj = Py_None;
14831 return resultobj;
14832 fail:
14833 return NULL;
14834 }
14835
14836
14837 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14838 PyObject *resultobj;
14839 wxDC *arg1 = (wxDC *) 0 ;
14840 int arg2 ;
14841 wxPoint *arg3 = (wxPoint *) 0 ;
14842 int arg4 = (int) 0 ;
14843 int arg5 = (int) 0 ;
14844 PyObject * obj0 = 0 ;
14845 PyObject * obj1 = 0 ;
14846 PyObject * obj2 = 0 ;
14847 PyObject * obj3 = 0 ;
14848 char *kwnames[] = {
14849 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14850 };
14851
14852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14854 if (SWIG_arg_fail(1)) SWIG_fail;
14855 {
14856 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14857 if (arg3 == NULL) SWIG_fail;
14858 }
14859 if (obj2) {
14860 {
14861 arg4 = (int)(SWIG_As_int(obj2));
14862 if (SWIG_arg_fail(4)) SWIG_fail;
14863 }
14864 }
14865 if (obj3) {
14866 {
14867 arg5 = (int)(SWIG_As_int(obj3));
14868 if (SWIG_arg_fail(5)) SWIG_fail;
14869 }
14870 }
14871 {
14872 PyThreadState* __tstate = wxPyBeginAllowThreads();
14873 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14874
14875 wxPyEndAllowThreads(__tstate);
14876 if (PyErr_Occurred()) SWIG_fail;
14877 }
14878 Py_INCREF(Py_None); resultobj = Py_None;
14879 {
14880 if (arg3) delete [] arg3;
14881 }
14882 return resultobj;
14883 fail:
14884 {
14885 if (arg3) delete [] arg3;
14886 }
14887 return NULL;
14888 }
14889
14890
14891 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14892 PyObject *resultobj;
14893 wxDC *arg1 = (wxDC *) 0 ;
14894 int arg2 ;
14895 wxPoint *arg3 = (wxPoint *) 0 ;
14896 int arg4 = (int) 0 ;
14897 int arg5 = (int) 0 ;
14898 int arg6 = (int) wxODDEVEN_RULE ;
14899 PyObject * obj0 = 0 ;
14900 PyObject * obj1 = 0 ;
14901 PyObject * obj2 = 0 ;
14902 PyObject * obj3 = 0 ;
14903 PyObject * obj4 = 0 ;
14904 char *kwnames[] = {
14905 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14906 };
14907
14908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14910 if (SWIG_arg_fail(1)) SWIG_fail;
14911 {
14912 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14913 if (arg3 == NULL) SWIG_fail;
14914 }
14915 if (obj2) {
14916 {
14917 arg4 = (int)(SWIG_As_int(obj2));
14918 if (SWIG_arg_fail(4)) SWIG_fail;
14919 }
14920 }
14921 if (obj3) {
14922 {
14923 arg5 = (int)(SWIG_As_int(obj3));
14924 if (SWIG_arg_fail(5)) SWIG_fail;
14925 }
14926 }
14927 if (obj4) {
14928 {
14929 arg6 = (int)(SWIG_As_int(obj4));
14930 if (SWIG_arg_fail(6)) SWIG_fail;
14931 }
14932 }
14933 {
14934 PyThreadState* __tstate = wxPyBeginAllowThreads();
14935 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14936
14937 wxPyEndAllowThreads(__tstate);
14938 if (PyErr_Occurred()) SWIG_fail;
14939 }
14940 Py_INCREF(Py_None); resultobj = Py_None;
14941 {
14942 if (arg3) delete [] arg3;
14943 }
14944 return resultobj;
14945 fail:
14946 {
14947 if (arg3) delete [] arg3;
14948 }
14949 return NULL;
14950 }
14951
14952
14953 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14954 PyObject *resultobj;
14955 wxDC *arg1 = (wxDC *) 0 ;
14956 wxString *arg2 = 0 ;
14957 wxRect *arg3 = 0 ;
14958 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14959 int arg5 = (int) -1 ;
14960 bool temp2 = false ;
14961 wxRect temp3 ;
14962 PyObject * obj0 = 0 ;
14963 PyObject * obj1 = 0 ;
14964 PyObject * obj2 = 0 ;
14965 PyObject * obj3 = 0 ;
14966 PyObject * obj4 = 0 ;
14967 char *kwnames[] = {
14968 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14969 };
14970
14971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14973 if (SWIG_arg_fail(1)) SWIG_fail;
14974 {
14975 arg2 = wxString_in_helper(obj1);
14976 if (arg2 == NULL) SWIG_fail;
14977 temp2 = true;
14978 }
14979 {
14980 arg3 = &temp3;
14981 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
14982 }
14983 if (obj3) {
14984 {
14985 arg4 = (int)(SWIG_As_int(obj3));
14986 if (SWIG_arg_fail(4)) SWIG_fail;
14987 }
14988 }
14989 if (obj4) {
14990 {
14991 arg5 = (int)(SWIG_As_int(obj4));
14992 if (SWIG_arg_fail(5)) SWIG_fail;
14993 }
14994 }
14995 {
14996 PyThreadState* __tstate = wxPyBeginAllowThreads();
14997 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
14998
14999 wxPyEndAllowThreads(__tstate);
15000 if (PyErr_Occurred()) SWIG_fail;
15001 }
15002 Py_INCREF(Py_None); resultobj = Py_None;
15003 {
15004 if (temp2)
15005 delete arg2;
15006 }
15007 return resultobj;
15008 fail:
15009 {
15010 if (temp2)
15011 delete arg2;
15012 }
15013 return NULL;
15014 }
15015
15016
15017 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
15018 PyObject *resultobj;
15019 wxDC *arg1 = (wxDC *) 0 ;
15020 wxString *arg2 = 0 ;
15021 wxBitmap *arg3 = 0 ;
15022 wxRect *arg4 = 0 ;
15023 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
15024 int arg6 = (int) -1 ;
15025 wxRect result;
15026 bool temp2 = false ;
15027 wxRect temp4 ;
15028 PyObject * obj0 = 0 ;
15029 PyObject * obj1 = 0 ;
15030 PyObject * obj2 = 0 ;
15031 PyObject * obj3 = 0 ;
15032 PyObject * obj4 = 0 ;
15033 PyObject * obj5 = 0 ;
15034 char *kwnames[] = {
15035 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
15036 };
15037
15038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
15039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15040 if (SWIG_arg_fail(1)) SWIG_fail;
15041 {
15042 arg2 = wxString_in_helper(obj1);
15043 if (arg2 == NULL) SWIG_fail;
15044 temp2 = true;
15045 }
15046 {
15047 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
15048 if (SWIG_arg_fail(3)) SWIG_fail;
15049 if (arg3 == NULL) {
15050 SWIG_null_ref("wxBitmap");
15051 }
15052 if (SWIG_arg_fail(3)) SWIG_fail;
15053 }
15054 {
15055 arg4 = &temp4;
15056 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
15057 }
15058 if (obj4) {
15059 {
15060 arg5 = (int)(SWIG_As_int(obj4));
15061 if (SWIG_arg_fail(5)) SWIG_fail;
15062 }
15063 }
15064 if (obj5) {
15065 {
15066 arg6 = (int)(SWIG_As_int(obj5));
15067 if (SWIG_arg_fail(6)) SWIG_fail;
15068 }
15069 }
15070 {
15071 PyThreadState* __tstate = wxPyBeginAllowThreads();
15072 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
15073
15074 wxPyEndAllowThreads(__tstate);
15075 if (PyErr_Occurred()) SWIG_fail;
15076 }
15077 {
15078 wxRect * resultptr;
15079 resultptr = new wxRect((wxRect &)(result));
15080 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15081 }
15082 {
15083 if (temp2)
15084 delete arg2;
15085 }
15086 return resultobj;
15087 fail:
15088 {
15089 if (temp2)
15090 delete arg2;
15091 }
15092 return NULL;
15093 }
15094
15095
15096 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
15097 PyObject *resultobj;
15098 wxDC *arg1 = (wxDC *) 0 ;
15099 int arg2 ;
15100 wxPoint *arg3 = (wxPoint *) 0 ;
15101 PyObject * obj0 = 0 ;
15102 PyObject * obj1 = 0 ;
15103 char *kwnames[] = {
15104 (char *) "self",(char *) "points", NULL
15105 };
15106
15107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
15108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15109 if (SWIG_arg_fail(1)) SWIG_fail;
15110 {
15111 arg3 = wxPoint_LIST_helper(obj1, &arg2);
15112 if (arg3 == NULL) SWIG_fail;
15113 }
15114 {
15115 PyThreadState* __tstate = wxPyBeginAllowThreads();
15116 (arg1)->DrawSpline(arg2,arg3);
15117
15118 wxPyEndAllowThreads(__tstate);
15119 if (PyErr_Occurred()) SWIG_fail;
15120 }
15121 Py_INCREF(Py_None); resultobj = Py_None;
15122 {
15123 if (arg3) delete [] arg3;
15124 }
15125 return resultobj;
15126 fail:
15127 {
15128 if (arg3) delete [] arg3;
15129 }
15130 return NULL;
15131 }
15132
15133
15134 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
15135 PyObject *resultobj;
15136 wxDC *arg1 = (wxDC *) 0 ;
15137 PyObject * obj0 = 0 ;
15138 char *kwnames[] = {
15139 (char *) "self", NULL
15140 };
15141
15142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
15143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15144 if (SWIG_arg_fail(1)) SWIG_fail;
15145 {
15146 PyThreadState* __tstate = wxPyBeginAllowThreads();
15147 (arg1)->Clear();
15148
15149 wxPyEndAllowThreads(__tstate);
15150 if (PyErr_Occurred()) SWIG_fail;
15151 }
15152 Py_INCREF(Py_None); resultobj = Py_None;
15153 return resultobj;
15154 fail:
15155 return NULL;
15156 }
15157
15158
15159 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
15160 PyObject *resultobj;
15161 wxDC *arg1 = (wxDC *) 0 ;
15162 wxString *arg2 = 0 ;
15163 bool result;
15164 bool temp2 = false ;
15165 PyObject * obj0 = 0 ;
15166 PyObject * obj1 = 0 ;
15167 char *kwnames[] = {
15168 (char *) "self",(char *) "message", NULL
15169 };
15170
15171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
15172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15173 if (SWIG_arg_fail(1)) SWIG_fail;
15174 {
15175 arg2 = wxString_in_helper(obj1);
15176 if (arg2 == NULL) SWIG_fail;
15177 temp2 = true;
15178 }
15179 {
15180 PyThreadState* __tstate = wxPyBeginAllowThreads();
15181 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
15182
15183 wxPyEndAllowThreads(__tstate);
15184 if (PyErr_Occurred()) SWIG_fail;
15185 }
15186 {
15187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15188 }
15189 {
15190 if (temp2)
15191 delete arg2;
15192 }
15193 return resultobj;
15194 fail:
15195 {
15196 if (temp2)
15197 delete arg2;
15198 }
15199 return NULL;
15200 }
15201
15202
15203 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
15204 PyObject *resultobj;
15205 wxDC *arg1 = (wxDC *) 0 ;
15206 PyObject * obj0 = 0 ;
15207 char *kwnames[] = {
15208 (char *) "self", NULL
15209 };
15210
15211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
15212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15213 if (SWIG_arg_fail(1)) SWIG_fail;
15214 {
15215 PyThreadState* __tstate = wxPyBeginAllowThreads();
15216 (arg1)->EndDoc();
15217
15218 wxPyEndAllowThreads(__tstate);
15219 if (PyErr_Occurred()) SWIG_fail;
15220 }
15221 Py_INCREF(Py_None); resultobj = Py_None;
15222 return resultobj;
15223 fail:
15224 return NULL;
15225 }
15226
15227
15228 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
15229 PyObject *resultobj;
15230 wxDC *arg1 = (wxDC *) 0 ;
15231 PyObject * obj0 = 0 ;
15232 char *kwnames[] = {
15233 (char *) "self", NULL
15234 };
15235
15236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
15237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15238 if (SWIG_arg_fail(1)) SWIG_fail;
15239 {
15240 PyThreadState* __tstate = wxPyBeginAllowThreads();
15241 (arg1)->StartPage();
15242
15243 wxPyEndAllowThreads(__tstate);
15244 if (PyErr_Occurred()) SWIG_fail;
15245 }
15246 Py_INCREF(Py_None); resultobj = Py_None;
15247 return resultobj;
15248 fail:
15249 return NULL;
15250 }
15251
15252
15253 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
15254 PyObject *resultobj;
15255 wxDC *arg1 = (wxDC *) 0 ;
15256 PyObject * obj0 = 0 ;
15257 char *kwnames[] = {
15258 (char *) "self", NULL
15259 };
15260
15261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
15262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15263 if (SWIG_arg_fail(1)) SWIG_fail;
15264 {
15265 PyThreadState* __tstate = wxPyBeginAllowThreads();
15266 (arg1)->EndPage();
15267
15268 wxPyEndAllowThreads(__tstate);
15269 if (PyErr_Occurred()) SWIG_fail;
15270 }
15271 Py_INCREF(Py_None); resultobj = Py_None;
15272 return resultobj;
15273 fail:
15274 return NULL;
15275 }
15276
15277
15278 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15279 PyObject *resultobj;
15280 wxDC *arg1 = (wxDC *) 0 ;
15281 wxFont *arg2 = 0 ;
15282 PyObject * obj0 = 0 ;
15283 PyObject * obj1 = 0 ;
15284 char *kwnames[] = {
15285 (char *) "self",(char *) "font", NULL
15286 };
15287
15288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
15289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15290 if (SWIG_arg_fail(1)) SWIG_fail;
15291 {
15292 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15293 if (SWIG_arg_fail(2)) SWIG_fail;
15294 if (arg2 == NULL) {
15295 SWIG_null_ref("wxFont");
15296 }
15297 if (SWIG_arg_fail(2)) SWIG_fail;
15298 }
15299 {
15300 PyThreadState* __tstate = wxPyBeginAllowThreads();
15301 (arg1)->SetFont((wxFont const &)*arg2);
15302
15303 wxPyEndAllowThreads(__tstate);
15304 if (PyErr_Occurred()) SWIG_fail;
15305 }
15306 Py_INCREF(Py_None); resultobj = Py_None;
15307 return resultobj;
15308 fail:
15309 return NULL;
15310 }
15311
15312
15313 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
15314 PyObject *resultobj;
15315 wxDC *arg1 = (wxDC *) 0 ;
15316 wxPen *arg2 = 0 ;
15317 PyObject * obj0 = 0 ;
15318 PyObject * obj1 = 0 ;
15319 char *kwnames[] = {
15320 (char *) "self",(char *) "pen", NULL
15321 };
15322
15323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
15324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15325 if (SWIG_arg_fail(1)) SWIG_fail;
15326 {
15327 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
15328 if (SWIG_arg_fail(2)) SWIG_fail;
15329 if (arg2 == NULL) {
15330 SWIG_null_ref("wxPen");
15331 }
15332 if (SWIG_arg_fail(2)) SWIG_fail;
15333 }
15334 {
15335 PyThreadState* __tstate = wxPyBeginAllowThreads();
15336 (arg1)->SetPen((wxPen const &)*arg2);
15337
15338 wxPyEndAllowThreads(__tstate);
15339 if (PyErr_Occurred()) SWIG_fail;
15340 }
15341 Py_INCREF(Py_None); resultobj = Py_None;
15342 return resultobj;
15343 fail:
15344 return NULL;
15345 }
15346
15347
15348 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15349 PyObject *resultobj;
15350 wxDC *arg1 = (wxDC *) 0 ;
15351 wxBrush *arg2 = 0 ;
15352 PyObject * obj0 = 0 ;
15353 PyObject * obj1 = 0 ;
15354 char *kwnames[] = {
15355 (char *) "self",(char *) "brush", NULL
15356 };
15357
15358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
15359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15360 if (SWIG_arg_fail(1)) SWIG_fail;
15361 {
15362 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
15363 if (SWIG_arg_fail(2)) SWIG_fail;
15364 if (arg2 == NULL) {
15365 SWIG_null_ref("wxBrush");
15366 }
15367 if (SWIG_arg_fail(2)) SWIG_fail;
15368 }
15369 {
15370 PyThreadState* __tstate = wxPyBeginAllowThreads();
15371 (arg1)->SetBrush((wxBrush const &)*arg2);
15372
15373 wxPyEndAllowThreads(__tstate);
15374 if (PyErr_Occurred()) SWIG_fail;
15375 }
15376 Py_INCREF(Py_None); resultobj = Py_None;
15377 return resultobj;
15378 fail:
15379 return NULL;
15380 }
15381
15382
15383 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15384 PyObject *resultobj;
15385 wxDC *arg1 = (wxDC *) 0 ;
15386 wxBrush *arg2 = 0 ;
15387 PyObject * obj0 = 0 ;
15388 PyObject * obj1 = 0 ;
15389 char *kwnames[] = {
15390 (char *) "self",(char *) "brush", NULL
15391 };
15392
15393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
15394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15395 if (SWIG_arg_fail(1)) SWIG_fail;
15396 {
15397 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
15398 if (SWIG_arg_fail(2)) SWIG_fail;
15399 if (arg2 == NULL) {
15400 SWIG_null_ref("wxBrush");
15401 }
15402 if (SWIG_arg_fail(2)) SWIG_fail;
15403 }
15404 {
15405 PyThreadState* __tstate = wxPyBeginAllowThreads();
15406 (arg1)->SetBackground((wxBrush const &)*arg2);
15407
15408 wxPyEndAllowThreads(__tstate);
15409 if (PyErr_Occurred()) SWIG_fail;
15410 }
15411 Py_INCREF(Py_None); resultobj = Py_None;
15412 return resultobj;
15413 fail:
15414 return NULL;
15415 }
15416
15417
15418 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15419 PyObject *resultobj;
15420 wxDC *arg1 = (wxDC *) 0 ;
15421 int arg2 ;
15422 PyObject * obj0 = 0 ;
15423 PyObject * obj1 = 0 ;
15424 char *kwnames[] = {
15425 (char *) "self",(char *) "mode", NULL
15426 };
15427
15428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
15429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15430 if (SWIG_arg_fail(1)) SWIG_fail;
15431 {
15432 arg2 = (int)(SWIG_As_int(obj1));
15433 if (SWIG_arg_fail(2)) SWIG_fail;
15434 }
15435 {
15436 PyThreadState* __tstate = wxPyBeginAllowThreads();
15437 (arg1)->SetBackgroundMode(arg2);
15438
15439 wxPyEndAllowThreads(__tstate);
15440 if (PyErr_Occurred()) SWIG_fail;
15441 }
15442 Py_INCREF(Py_None); resultobj = Py_None;
15443 return resultobj;
15444 fail:
15445 return NULL;
15446 }
15447
15448
15449 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
15450 PyObject *resultobj;
15451 wxDC *arg1 = (wxDC *) 0 ;
15452 wxPalette *arg2 = 0 ;
15453 PyObject * obj0 = 0 ;
15454 PyObject * obj1 = 0 ;
15455 char *kwnames[] = {
15456 (char *) "self",(char *) "palette", NULL
15457 };
15458
15459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
15464 if (SWIG_arg_fail(2)) SWIG_fail;
15465 if (arg2 == NULL) {
15466 SWIG_null_ref("wxPalette");
15467 }
15468 if (SWIG_arg_fail(2)) SWIG_fail;
15469 }
15470 {
15471 PyThreadState* __tstate = wxPyBeginAllowThreads();
15472 (arg1)->SetPalette((wxPalette const &)*arg2);
15473
15474 wxPyEndAllowThreads(__tstate);
15475 if (PyErr_Occurred()) SWIG_fail;
15476 }
15477 Py_INCREF(Py_None); resultobj = Py_None;
15478 return resultobj;
15479 fail:
15480 return NULL;
15481 }
15482
15483
15484 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
15485 PyObject *resultobj;
15486 wxDC *arg1 = (wxDC *) 0 ;
15487 PyObject * obj0 = 0 ;
15488 char *kwnames[] = {
15489 (char *) "self", NULL
15490 };
15491
15492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
15493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15494 if (SWIG_arg_fail(1)) SWIG_fail;
15495 {
15496 PyThreadState* __tstate = wxPyBeginAllowThreads();
15497 (arg1)->DestroyClippingRegion();
15498
15499 wxPyEndAllowThreads(__tstate);
15500 if (PyErr_Occurred()) SWIG_fail;
15501 }
15502 Py_INCREF(Py_None); resultobj = Py_None;
15503 return resultobj;
15504 fail:
15505 return NULL;
15506 }
15507
15508
15509 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
15510 PyObject *resultobj;
15511 wxDC *arg1 = (wxDC *) 0 ;
15512 int *arg2 = (int *) 0 ;
15513 int *arg3 = (int *) 0 ;
15514 int *arg4 = (int *) 0 ;
15515 int *arg5 = (int *) 0 ;
15516 int temp2 ;
15517 int res2 = 0 ;
15518 int temp3 ;
15519 int res3 = 0 ;
15520 int temp4 ;
15521 int res4 = 0 ;
15522 int temp5 ;
15523 int res5 = 0 ;
15524 PyObject * obj0 = 0 ;
15525 char *kwnames[] = {
15526 (char *) "self", NULL
15527 };
15528
15529 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15530 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15531 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15532 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
15534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15535 if (SWIG_arg_fail(1)) SWIG_fail;
15536 {
15537 PyThreadState* __tstate = wxPyBeginAllowThreads();
15538 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
15539
15540 wxPyEndAllowThreads(__tstate);
15541 if (PyErr_Occurred()) SWIG_fail;
15542 }
15543 Py_INCREF(Py_None); resultobj = Py_None;
15544 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15545 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15546 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15547 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15548 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15549 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15550 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15551 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15552 return resultobj;
15553 fail:
15554 return NULL;
15555 }
15556
15557
15558 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
15559 PyObject *resultobj;
15560 wxDC *arg1 = (wxDC *) 0 ;
15561 wxRect result;
15562 PyObject * obj0 = 0 ;
15563 char *kwnames[] = {
15564 (char *) "self", NULL
15565 };
15566
15567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
15568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15569 if (SWIG_arg_fail(1)) SWIG_fail;
15570 {
15571 PyThreadState* __tstate = wxPyBeginAllowThreads();
15572 result = wxDC_GetClippingRect(arg1);
15573
15574 wxPyEndAllowThreads(__tstate);
15575 if (PyErr_Occurred()) SWIG_fail;
15576 }
15577 {
15578 wxRect * resultptr;
15579 resultptr = new wxRect((wxRect &)(result));
15580 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15581 }
15582 return resultobj;
15583 fail:
15584 return NULL;
15585 }
15586
15587
15588 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
15589 PyObject *resultobj;
15590 wxDC *arg1 = (wxDC *) 0 ;
15591 int result;
15592 PyObject * obj0 = 0 ;
15593 char *kwnames[] = {
15594 (char *) "self", NULL
15595 };
15596
15597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
15598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15599 if (SWIG_arg_fail(1)) SWIG_fail;
15600 {
15601 PyThreadState* __tstate = wxPyBeginAllowThreads();
15602 result = (int)((wxDC const *)arg1)->GetCharHeight();
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_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
15617 PyObject *resultobj;
15618 wxDC *arg1 = (wxDC *) 0 ;
15619 int result;
15620 PyObject * obj0 = 0 ;
15621 char *kwnames[] = {
15622 (char *) "self", NULL
15623 };
15624
15625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
15626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15627 if (SWIG_arg_fail(1)) SWIG_fail;
15628 {
15629 PyThreadState* __tstate = wxPyBeginAllowThreads();
15630 result = (int)((wxDC const *)arg1)->GetCharWidth();
15631
15632 wxPyEndAllowThreads(__tstate);
15633 if (PyErr_Occurred()) SWIG_fail;
15634 }
15635 {
15636 resultobj = SWIG_From_int((int)(result));
15637 }
15638 return resultobj;
15639 fail:
15640 return NULL;
15641 }
15642
15643
15644 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15645 PyObject *resultobj;
15646 wxDC *arg1 = (wxDC *) 0 ;
15647 wxString *arg2 = 0 ;
15648 int *arg3 = (int *) 0 ;
15649 int *arg4 = (int *) 0 ;
15650 bool temp2 = false ;
15651 int temp3 ;
15652 int res3 = 0 ;
15653 int temp4 ;
15654 int res4 = 0 ;
15655 PyObject * obj0 = 0 ;
15656 PyObject * obj1 = 0 ;
15657 char *kwnames[] = {
15658 (char *) "self",(char *) "string", NULL
15659 };
15660
15661 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15662 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15665 if (SWIG_arg_fail(1)) SWIG_fail;
15666 {
15667 arg2 = wxString_in_helper(obj1);
15668 if (arg2 == NULL) SWIG_fail;
15669 temp2 = true;
15670 }
15671 {
15672 PyThreadState* __tstate = wxPyBeginAllowThreads();
15673 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15674
15675 wxPyEndAllowThreads(__tstate);
15676 if (PyErr_Occurred()) SWIG_fail;
15677 }
15678 Py_INCREF(Py_None); resultobj = Py_None;
15679 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15680 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15681 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15682 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15683 {
15684 if (temp2)
15685 delete arg2;
15686 }
15687 return resultobj;
15688 fail:
15689 {
15690 if (temp2)
15691 delete arg2;
15692 }
15693 return NULL;
15694 }
15695
15696
15697 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15698 PyObject *resultobj;
15699 wxDC *arg1 = (wxDC *) 0 ;
15700 wxString *arg2 = 0 ;
15701 int *arg3 = (int *) 0 ;
15702 int *arg4 = (int *) 0 ;
15703 int *arg5 = (int *) 0 ;
15704 int *arg6 = (int *) 0 ;
15705 wxFont *arg7 = (wxFont *) NULL ;
15706 bool temp2 = false ;
15707 int temp3 ;
15708 int res3 = 0 ;
15709 int temp4 ;
15710 int res4 = 0 ;
15711 int temp5 ;
15712 int res5 = 0 ;
15713 int temp6 ;
15714 int res6 = 0 ;
15715 PyObject * obj0 = 0 ;
15716 PyObject * obj1 = 0 ;
15717 PyObject * obj2 = 0 ;
15718 char *kwnames[] = {
15719 (char *) "self",(char *) "string",(char *) "font", NULL
15720 };
15721
15722 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15723 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15724 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15725 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15728 if (SWIG_arg_fail(1)) SWIG_fail;
15729 {
15730 arg2 = wxString_in_helper(obj1);
15731 if (arg2 == NULL) SWIG_fail;
15732 temp2 = true;
15733 }
15734 if (obj2) {
15735 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15736 if (SWIG_arg_fail(7)) SWIG_fail;
15737 }
15738 {
15739 PyThreadState* __tstate = wxPyBeginAllowThreads();
15740 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15741
15742 wxPyEndAllowThreads(__tstate);
15743 if (PyErr_Occurred()) SWIG_fail;
15744 }
15745 Py_INCREF(Py_None); resultobj = Py_None;
15746 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15747 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15748 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15749 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15750 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15751 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15752 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15753 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15754 {
15755 if (temp2)
15756 delete arg2;
15757 }
15758 return resultobj;
15759 fail:
15760 {
15761 if (temp2)
15762 delete arg2;
15763 }
15764 return NULL;
15765 }
15766
15767
15768 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15769 PyObject *resultobj;
15770 wxDC *arg1 = (wxDC *) 0 ;
15771 wxString *arg2 = 0 ;
15772 int *arg3 = (int *) 0 ;
15773 int *arg4 = (int *) 0 ;
15774 int *arg5 = (int *) 0 ;
15775 wxFont *arg6 = (wxFont *) NULL ;
15776 bool temp2 = false ;
15777 int temp3 ;
15778 int res3 = 0 ;
15779 int temp4 ;
15780 int res4 = 0 ;
15781 int temp5 ;
15782 int res5 = 0 ;
15783 PyObject * obj0 = 0 ;
15784 PyObject * obj1 = 0 ;
15785 PyObject * obj2 = 0 ;
15786 char *kwnames[] = {
15787 (char *) "self",(char *) "text",(char *) "font", NULL
15788 };
15789
15790 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15791 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15792 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15795 if (SWIG_arg_fail(1)) SWIG_fail;
15796 {
15797 arg2 = wxString_in_helper(obj1);
15798 if (arg2 == NULL) SWIG_fail;
15799 temp2 = true;
15800 }
15801 if (obj2) {
15802 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15803 if (SWIG_arg_fail(6)) SWIG_fail;
15804 }
15805 {
15806 PyThreadState* __tstate = wxPyBeginAllowThreads();
15807 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15808
15809 wxPyEndAllowThreads(__tstate);
15810 if (PyErr_Occurred()) SWIG_fail;
15811 }
15812 Py_INCREF(Py_None); resultobj = Py_None;
15813 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15814 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15815 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15816 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15817 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15818 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15819 {
15820 if (temp2)
15821 delete arg2;
15822 }
15823 return resultobj;
15824 fail:
15825 {
15826 if (temp2)
15827 delete arg2;
15828 }
15829 return NULL;
15830 }
15831
15832
15833 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15834 PyObject *resultobj;
15835 wxDC *arg1 = (wxDC *) 0 ;
15836 wxString *arg2 = 0 ;
15837 wxArrayInt result;
15838 bool temp2 = false ;
15839 PyObject * obj0 = 0 ;
15840 PyObject * obj1 = 0 ;
15841 char *kwnames[] = {
15842 (char *) "self",(char *) "text", NULL
15843 };
15844
15845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) 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 arg2 = wxString_in_helper(obj1);
15850 if (arg2 == NULL) SWIG_fail;
15851 temp2 = true;
15852 }
15853 {
15854 PyThreadState* __tstate = wxPyBeginAllowThreads();
15855 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15856
15857 wxPyEndAllowThreads(__tstate);
15858 if (PyErr_Occurred()) SWIG_fail;
15859 }
15860 {
15861 resultobj = PyList_New(0);
15862 size_t idx;
15863 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15864 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15865 PyList_Append(resultobj, val);
15866 Py_DECREF(val);
15867 }
15868 }
15869 {
15870 if (temp2)
15871 delete arg2;
15872 }
15873 return resultobj;
15874 fail:
15875 {
15876 if (temp2)
15877 delete arg2;
15878 }
15879 return NULL;
15880 }
15881
15882
15883 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15884 PyObject *resultobj;
15885 wxDC *arg1 = (wxDC *) 0 ;
15886 wxSize result;
15887 PyObject * obj0 = 0 ;
15888 char *kwnames[] = {
15889 (char *) "self", NULL
15890 };
15891
15892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15894 if (SWIG_arg_fail(1)) SWIG_fail;
15895 {
15896 PyThreadState* __tstate = wxPyBeginAllowThreads();
15897 result = (arg1)->GetSize();
15898
15899 wxPyEndAllowThreads(__tstate);
15900 if (PyErr_Occurred()) SWIG_fail;
15901 }
15902 {
15903 wxSize * resultptr;
15904 resultptr = new wxSize((wxSize &)(result));
15905 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15906 }
15907 return resultobj;
15908 fail:
15909 return NULL;
15910 }
15911
15912
15913 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15914 PyObject *resultobj;
15915 wxDC *arg1 = (wxDC *) 0 ;
15916 int *arg2 = (int *) 0 ;
15917 int *arg3 = (int *) 0 ;
15918 int temp2 ;
15919 int res2 = 0 ;
15920 int temp3 ;
15921 int res3 = 0 ;
15922 PyObject * obj0 = 0 ;
15923 char *kwnames[] = {
15924 (char *) "self", NULL
15925 };
15926
15927 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15928 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15931 if (SWIG_arg_fail(1)) SWIG_fail;
15932 {
15933 PyThreadState* __tstate = wxPyBeginAllowThreads();
15934 (arg1)->GetSize(arg2,arg3);
15935
15936 wxPyEndAllowThreads(__tstate);
15937 if (PyErr_Occurred()) SWIG_fail;
15938 }
15939 Py_INCREF(Py_None); resultobj = Py_None;
15940 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15941 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15942 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15943 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15944 return resultobj;
15945 fail:
15946 return NULL;
15947 }
15948
15949
15950 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15951 PyObject *resultobj;
15952 wxDC *arg1 = (wxDC *) 0 ;
15953 wxSize result;
15954 PyObject * obj0 = 0 ;
15955 char *kwnames[] = {
15956 (char *) "self", NULL
15957 };
15958
15959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
15960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15961 if (SWIG_arg_fail(1)) SWIG_fail;
15962 {
15963 PyThreadState* __tstate = wxPyBeginAllowThreads();
15964 result = ((wxDC const *)arg1)->GetSizeMM();
15965
15966 wxPyEndAllowThreads(__tstate);
15967 if (PyErr_Occurred()) SWIG_fail;
15968 }
15969 {
15970 wxSize * resultptr;
15971 resultptr = new wxSize((wxSize &)(result));
15972 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15973 }
15974 return resultobj;
15975 fail:
15976 return NULL;
15977 }
15978
15979
15980 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15981 PyObject *resultobj;
15982 wxDC *arg1 = (wxDC *) 0 ;
15983 int *arg2 = (int *) 0 ;
15984 int *arg3 = (int *) 0 ;
15985 int temp2 ;
15986 int res2 = 0 ;
15987 int temp3 ;
15988 int res3 = 0 ;
15989 PyObject * obj0 = 0 ;
15990 char *kwnames[] = {
15991 (char *) "self", NULL
15992 };
15993
15994 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15995 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
15997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15998 if (SWIG_arg_fail(1)) SWIG_fail;
15999 {
16000 PyThreadState* __tstate = wxPyBeginAllowThreads();
16001 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
16002
16003 wxPyEndAllowThreads(__tstate);
16004 if (PyErr_Occurred()) SWIG_fail;
16005 }
16006 Py_INCREF(Py_None); resultobj = Py_None;
16007 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16008 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16009 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16010 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16011 return resultobj;
16012 fail:
16013 return NULL;
16014 }
16015
16016
16017 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
16018 PyObject *resultobj;
16019 wxDC *arg1 = (wxDC *) 0 ;
16020 int arg2 ;
16021 int result;
16022 PyObject * obj0 = 0 ;
16023 PyObject * obj1 = 0 ;
16024 char *kwnames[] = {
16025 (char *) "self",(char *) "x", NULL
16026 };
16027
16028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
16029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16030 if (SWIG_arg_fail(1)) SWIG_fail;
16031 {
16032 arg2 = (int)(SWIG_As_int(obj1));
16033 if (SWIG_arg_fail(2)) SWIG_fail;
16034 }
16035 {
16036 PyThreadState* __tstate = wxPyBeginAllowThreads();
16037 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
16038
16039 wxPyEndAllowThreads(__tstate);
16040 if (PyErr_Occurred()) SWIG_fail;
16041 }
16042 {
16043 resultobj = SWIG_From_int((int)(result));
16044 }
16045 return resultobj;
16046 fail:
16047 return NULL;
16048 }
16049
16050
16051 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
16052 PyObject *resultobj;
16053 wxDC *arg1 = (wxDC *) 0 ;
16054 int arg2 ;
16055 int result;
16056 PyObject * obj0 = 0 ;
16057 PyObject * obj1 = 0 ;
16058 char *kwnames[] = {
16059 (char *) "self",(char *) "y", NULL
16060 };
16061
16062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
16063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16064 if (SWIG_arg_fail(1)) SWIG_fail;
16065 {
16066 arg2 = (int)(SWIG_As_int(obj1));
16067 if (SWIG_arg_fail(2)) SWIG_fail;
16068 }
16069 {
16070 PyThreadState* __tstate = wxPyBeginAllowThreads();
16071 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
16072
16073 wxPyEndAllowThreads(__tstate);
16074 if (PyErr_Occurred()) SWIG_fail;
16075 }
16076 {
16077 resultobj = SWIG_From_int((int)(result));
16078 }
16079 return resultobj;
16080 fail:
16081 return NULL;
16082 }
16083
16084
16085 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
16086 PyObject *resultobj;
16087 wxDC *arg1 = (wxDC *) 0 ;
16088 int arg2 ;
16089 int result;
16090 PyObject * obj0 = 0 ;
16091 PyObject * obj1 = 0 ;
16092 char *kwnames[] = {
16093 (char *) "self",(char *) "x", NULL
16094 };
16095
16096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
16097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16098 if (SWIG_arg_fail(1)) SWIG_fail;
16099 {
16100 arg2 = (int)(SWIG_As_int(obj1));
16101 if (SWIG_arg_fail(2)) SWIG_fail;
16102 }
16103 {
16104 PyThreadState* __tstate = wxPyBeginAllowThreads();
16105 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
16106
16107 wxPyEndAllowThreads(__tstate);
16108 if (PyErr_Occurred()) SWIG_fail;
16109 }
16110 {
16111 resultobj = SWIG_From_int((int)(result));
16112 }
16113 return resultobj;
16114 fail:
16115 return NULL;
16116 }
16117
16118
16119 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
16120 PyObject *resultobj;
16121 wxDC *arg1 = (wxDC *) 0 ;
16122 int arg2 ;
16123 int result;
16124 PyObject * obj0 = 0 ;
16125 PyObject * obj1 = 0 ;
16126 char *kwnames[] = {
16127 (char *) "self",(char *) "y", NULL
16128 };
16129
16130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
16131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16132 if (SWIG_arg_fail(1)) SWIG_fail;
16133 {
16134 arg2 = (int)(SWIG_As_int(obj1));
16135 if (SWIG_arg_fail(2)) SWIG_fail;
16136 }
16137 {
16138 PyThreadState* __tstate = wxPyBeginAllowThreads();
16139 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
16140
16141 wxPyEndAllowThreads(__tstate);
16142 if (PyErr_Occurred()) SWIG_fail;
16143 }
16144 {
16145 resultobj = SWIG_From_int((int)(result));
16146 }
16147 return resultobj;
16148 fail:
16149 return NULL;
16150 }
16151
16152
16153 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
16154 PyObject *resultobj;
16155 wxDC *arg1 = (wxDC *) 0 ;
16156 int arg2 ;
16157 int result;
16158 PyObject * obj0 = 0 ;
16159 PyObject * obj1 = 0 ;
16160 char *kwnames[] = {
16161 (char *) "self",(char *) "x", NULL
16162 };
16163
16164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
16165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16166 if (SWIG_arg_fail(1)) SWIG_fail;
16167 {
16168 arg2 = (int)(SWIG_As_int(obj1));
16169 if (SWIG_arg_fail(2)) SWIG_fail;
16170 }
16171 {
16172 PyThreadState* __tstate = wxPyBeginAllowThreads();
16173 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
16174
16175 wxPyEndAllowThreads(__tstate);
16176 if (PyErr_Occurred()) SWIG_fail;
16177 }
16178 {
16179 resultobj = SWIG_From_int((int)(result));
16180 }
16181 return resultobj;
16182 fail:
16183 return NULL;
16184 }
16185
16186
16187 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
16188 PyObject *resultobj;
16189 wxDC *arg1 = (wxDC *) 0 ;
16190 int arg2 ;
16191 int result;
16192 PyObject * obj0 = 0 ;
16193 PyObject * obj1 = 0 ;
16194 char *kwnames[] = {
16195 (char *) "self",(char *) "y", NULL
16196 };
16197
16198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
16199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16200 if (SWIG_arg_fail(1)) SWIG_fail;
16201 {
16202 arg2 = (int)(SWIG_As_int(obj1));
16203 if (SWIG_arg_fail(2)) SWIG_fail;
16204 }
16205 {
16206 PyThreadState* __tstate = wxPyBeginAllowThreads();
16207 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
16208
16209 wxPyEndAllowThreads(__tstate);
16210 if (PyErr_Occurred()) SWIG_fail;
16211 }
16212 {
16213 resultobj = SWIG_From_int((int)(result));
16214 }
16215 return resultobj;
16216 fail:
16217 return NULL;
16218 }
16219
16220
16221 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
16222 PyObject *resultobj;
16223 wxDC *arg1 = (wxDC *) 0 ;
16224 int arg2 ;
16225 int result;
16226 PyObject * obj0 = 0 ;
16227 PyObject * obj1 = 0 ;
16228 char *kwnames[] = {
16229 (char *) "self",(char *) "x", NULL
16230 };
16231
16232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
16233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16234 if (SWIG_arg_fail(1)) SWIG_fail;
16235 {
16236 arg2 = (int)(SWIG_As_int(obj1));
16237 if (SWIG_arg_fail(2)) SWIG_fail;
16238 }
16239 {
16240 PyThreadState* __tstate = wxPyBeginAllowThreads();
16241 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
16242
16243 wxPyEndAllowThreads(__tstate);
16244 if (PyErr_Occurred()) SWIG_fail;
16245 }
16246 {
16247 resultobj = SWIG_From_int((int)(result));
16248 }
16249 return resultobj;
16250 fail:
16251 return NULL;
16252 }
16253
16254
16255 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
16256 PyObject *resultobj;
16257 wxDC *arg1 = (wxDC *) 0 ;
16258 int arg2 ;
16259 int result;
16260 PyObject * obj0 = 0 ;
16261 PyObject * obj1 = 0 ;
16262 char *kwnames[] = {
16263 (char *) "self",(char *) "y", NULL
16264 };
16265
16266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
16267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16268 if (SWIG_arg_fail(1)) SWIG_fail;
16269 {
16270 arg2 = (int)(SWIG_As_int(obj1));
16271 if (SWIG_arg_fail(2)) SWIG_fail;
16272 }
16273 {
16274 PyThreadState* __tstate = wxPyBeginAllowThreads();
16275 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
16276
16277 wxPyEndAllowThreads(__tstate);
16278 if (PyErr_Occurred()) SWIG_fail;
16279 }
16280 {
16281 resultobj = SWIG_From_int((int)(result));
16282 }
16283 return resultobj;
16284 fail:
16285 return NULL;
16286 }
16287
16288
16289 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16290 PyObject *resultobj;
16291 wxDC *arg1 = (wxDC *) 0 ;
16292 bool result;
16293 PyObject * obj0 = 0 ;
16294 char *kwnames[] = {
16295 (char *) "self", NULL
16296 };
16297
16298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
16299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16300 if (SWIG_arg_fail(1)) SWIG_fail;
16301 {
16302 PyThreadState* __tstate = wxPyBeginAllowThreads();
16303 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
16304
16305 wxPyEndAllowThreads(__tstate);
16306 if (PyErr_Occurred()) SWIG_fail;
16307 }
16308 {
16309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16310 }
16311 return resultobj;
16312 fail:
16313 return NULL;
16314 }
16315
16316
16317 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
16318 PyObject *resultobj;
16319 wxDC *arg1 = (wxDC *) 0 ;
16320 bool result;
16321 PyObject * obj0 = 0 ;
16322 char *kwnames[] = {
16323 (char *) "self", NULL
16324 };
16325
16326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
16327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16328 if (SWIG_arg_fail(1)) SWIG_fail;
16329 {
16330 PyThreadState* __tstate = wxPyBeginAllowThreads();
16331 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
16332
16333 wxPyEndAllowThreads(__tstate);
16334 if (PyErr_Occurred()) SWIG_fail;
16335 }
16336 {
16337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16338 }
16339 return resultobj;
16340 fail:
16341 return NULL;
16342 }
16343
16344
16345 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
16346 PyObject *resultobj;
16347 wxDC *arg1 = (wxDC *) 0 ;
16348 int result;
16349 PyObject * obj0 = 0 ;
16350 char *kwnames[] = {
16351 (char *) "self", NULL
16352 };
16353
16354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
16359 result = (int)((wxDC const *)arg1)->GetDepth();
16360
16361 wxPyEndAllowThreads(__tstate);
16362 if (PyErr_Occurred()) SWIG_fail;
16363 }
16364 {
16365 resultobj = SWIG_From_int((int)(result));
16366 }
16367 return resultobj;
16368 fail:
16369 return NULL;
16370 }
16371
16372
16373 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
16374 PyObject *resultobj;
16375 wxDC *arg1 = (wxDC *) 0 ;
16376 wxSize result;
16377 PyObject * obj0 = 0 ;
16378 char *kwnames[] = {
16379 (char *) "self", NULL
16380 };
16381
16382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
16383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16384 if (SWIG_arg_fail(1)) SWIG_fail;
16385 {
16386 PyThreadState* __tstate = wxPyBeginAllowThreads();
16387 result = ((wxDC const *)arg1)->GetPPI();
16388
16389 wxPyEndAllowThreads(__tstate);
16390 if (PyErr_Occurred()) SWIG_fail;
16391 }
16392 {
16393 wxSize * resultptr;
16394 resultptr = new wxSize((wxSize &)(result));
16395 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16396 }
16397 return resultobj;
16398 fail:
16399 return NULL;
16400 }
16401
16402
16403 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
16404 PyObject *resultobj;
16405 wxDC *arg1 = (wxDC *) 0 ;
16406 bool result;
16407 PyObject * obj0 = 0 ;
16408 char *kwnames[] = {
16409 (char *) "self", NULL
16410 };
16411
16412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
16413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16414 if (SWIG_arg_fail(1)) SWIG_fail;
16415 {
16416 PyThreadState* __tstate = wxPyBeginAllowThreads();
16417 result = (bool)((wxDC const *)arg1)->Ok();
16418
16419 wxPyEndAllowThreads(__tstate);
16420 if (PyErr_Occurred()) SWIG_fail;
16421 }
16422 {
16423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16424 }
16425 return resultobj;
16426 fail:
16427 return NULL;
16428 }
16429
16430
16431 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
16432 PyObject *resultobj;
16433 wxDC *arg1 = (wxDC *) 0 ;
16434 int result;
16435 PyObject * obj0 = 0 ;
16436 char *kwnames[] = {
16437 (char *) "self", NULL
16438 };
16439
16440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
16441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16442 if (SWIG_arg_fail(1)) SWIG_fail;
16443 {
16444 PyThreadState* __tstate = wxPyBeginAllowThreads();
16445 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
16446
16447 wxPyEndAllowThreads(__tstate);
16448 if (PyErr_Occurred()) SWIG_fail;
16449 }
16450 {
16451 resultobj = SWIG_From_int((int)(result));
16452 }
16453 return resultobj;
16454 fail:
16455 return NULL;
16456 }
16457
16458
16459 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16460 PyObject *resultobj;
16461 wxDC *arg1 = (wxDC *) 0 ;
16462 wxBrush *result;
16463 PyObject * obj0 = 0 ;
16464 char *kwnames[] = {
16465 (char *) "self", NULL
16466 };
16467
16468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
16469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16470 if (SWIG_arg_fail(1)) SWIG_fail;
16471 {
16472 PyThreadState* __tstate = wxPyBeginAllowThreads();
16473 {
16474 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
16475 result = (wxBrush *) &_result_ref;
16476 }
16477
16478 wxPyEndAllowThreads(__tstate);
16479 if (PyErr_Occurred()) SWIG_fail;
16480 }
16481 {
16482 wxBrush* resultptr = new wxBrush(*result);
16483 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
16484 }
16485 return resultobj;
16486 fail:
16487 return NULL;
16488 }
16489
16490
16491 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
16492 PyObject *resultobj;
16493 wxDC *arg1 = (wxDC *) 0 ;
16494 wxBrush *result;
16495 PyObject * obj0 = 0 ;
16496 char *kwnames[] = {
16497 (char *) "self", NULL
16498 };
16499
16500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
16501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16502 if (SWIG_arg_fail(1)) SWIG_fail;
16503 {
16504 PyThreadState* __tstate = wxPyBeginAllowThreads();
16505 {
16506 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
16507 result = (wxBrush *) &_result_ref;
16508 }
16509
16510 wxPyEndAllowThreads(__tstate);
16511 if (PyErr_Occurred()) SWIG_fail;
16512 }
16513 {
16514 wxBrush* resultptr = new wxBrush(*result);
16515 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
16516 }
16517 return resultobj;
16518 fail:
16519 return NULL;
16520 }
16521
16522
16523 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
16524 PyObject *resultobj;
16525 wxDC *arg1 = (wxDC *) 0 ;
16526 wxFont *result;
16527 PyObject * obj0 = 0 ;
16528 char *kwnames[] = {
16529 (char *) "self", NULL
16530 };
16531
16532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
16533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16534 if (SWIG_arg_fail(1)) SWIG_fail;
16535 {
16536 PyThreadState* __tstate = wxPyBeginAllowThreads();
16537 {
16538 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
16539 result = (wxFont *) &_result_ref;
16540 }
16541
16542 wxPyEndAllowThreads(__tstate);
16543 if (PyErr_Occurred()) SWIG_fail;
16544 }
16545 {
16546 wxFont* resultptr = new wxFont(*result);
16547 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
16548 }
16549 return resultobj;
16550 fail:
16551 return NULL;
16552 }
16553
16554
16555 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
16556 PyObject *resultobj;
16557 wxDC *arg1 = (wxDC *) 0 ;
16558 wxPen *result;
16559 PyObject * obj0 = 0 ;
16560 char *kwnames[] = {
16561 (char *) "self", NULL
16562 };
16563
16564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
16565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16566 if (SWIG_arg_fail(1)) SWIG_fail;
16567 {
16568 PyThreadState* __tstate = wxPyBeginAllowThreads();
16569 {
16570 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
16571 result = (wxPen *) &_result_ref;
16572 }
16573
16574 wxPyEndAllowThreads(__tstate);
16575 if (PyErr_Occurred()) SWIG_fail;
16576 }
16577 {
16578 wxPen* resultptr = new wxPen(*result);
16579 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
16580 }
16581 return resultobj;
16582 fail:
16583 return NULL;
16584 }
16585
16586
16587 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16588 PyObject *resultobj;
16589 wxDC *arg1 = (wxDC *) 0 ;
16590 wxColour *result;
16591 PyObject * obj0 = 0 ;
16592 char *kwnames[] = {
16593 (char *) "self", NULL
16594 };
16595
16596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
16597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16598 if (SWIG_arg_fail(1)) SWIG_fail;
16599 {
16600 PyThreadState* __tstate = wxPyBeginAllowThreads();
16601 {
16602 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
16603 result = (wxColour *) &_result_ref;
16604 }
16605
16606 wxPyEndAllowThreads(__tstate);
16607 if (PyErr_Occurred()) SWIG_fail;
16608 }
16609 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16610 return resultobj;
16611 fail:
16612 return NULL;
16613 }
16614
16615
16616 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16617 PyObject *resultobj;
16618 wxDC *arg1 = (wxDC *) 0 ;
16619 wxColour *result;
16620 PyObject * obj0 = 0 ;
16621 char *kwnames[] = {
16622 (char *) "self", NULL
16623 };
16624
16625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
16626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16627 if (SWIG_arg_fail(1)) SWIG_fail;
16628 {
16629 PyThreadState* __tstate = wxPyBeginAllowThreads();
16630 {
16631 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
16632 result = (wxColour *) &_result_ref;
16633 }
16634
16635 wxPyEndAllowThreads(__tstate);
16636 if (PyErr_Occurred()) SWIG_fail;
16637 }
16638 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16639 return resultobj;
16640 fail:
16641 return NULL;
16642 }
16643
16644
16645 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16646 PyObject *resultobj;
16647 wxDC *arg1 = (wxDC *) 0 ;
16648 wxColour *arg2 = 0 ;
16649 wxColour temp2 ;
16650 PyObject * obj0 = 0 ;
16651 PyObject * obj1 = 0 ;
16652 char *kwnames[] = {
16653 (char *) "self",(char *) "colour", NULL
16654 };
16655
16656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16658 if (SWIG_arg_fail(1)) SWIG_fail;
16659 {
16660 arg2 = &temp2;
16661 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16662 }
16663 {
16664 PyThreadState* __tstate = wxPyBeginAllowThreads();
16665 (arg1)->SetTextForeground((wxColour const &)*arg2);
16666
16667 wxPyEndAllowThreads(__tstate);
16668 if (PyErr_Occurred()) SWIG_fail;
16669 }
16670 Py_INCREF(Py_None); resultobj = Py_None;
16671 return resultobj;
16672 fail:
16673 return NULL;
16674 }
16675
16676
16677 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16678 PyObject *resultobj;
16679 wxDC *arg1 = (wxDC *) 0 ;
16680 wxColour *arg2 = 0 ;
16681 wxColour temp2 ;
16682 PyObject * obj0 = 0 ;
16683 PyObject * obj1 = 0 ;
16684 char *kwnames[] = {
16685 (char *) "self",(char *) "colour", NULL
16686 };
16687
16688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16690 if (SWIG_arg_fail(1)) SWIG_fail;
16691 {
16692 arg2 = &temp2;
16693 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16694 }
16695 {
16696 PyThreadState* __tstate = wxPyBeginAllowThreads();
16697 (arg1)->SetTextBackground((wxColour const &)*arg2);
16698
16699 wxPyEndAllowThreads(__tstate);
16700 if (PyErr_Occurred()) SWIG_fail;
16701 }
16702 Py_INCREF(Py_None); resultobj = Py_None;
16703 return resultobj;
16704 fail:
16705 return NULL;
16706 }
16707
16708
16709 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16710 PyObject *resultobj;
16711 wxDC *arg1 = (wxDC *) 0 ;
16712 int result;
16713 PyObject * obj0 = 0 ;
16714 char *kwnames[] = {
16715 (char *) "self", NULL
16716 };
16717
16718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16720 if (SWIG_arg_fail(1)) SWIG_fail;
16721 {
16722 PyThreadState* __tstate = wxPyBeginAllowThreads();
16723 result = (int)((wxDC const *)arg1)->GetMapMode();
16724
16725 wxPyEndAllowThreads(__tstate);
16726 if (PyErr_Occurred()) SWIG_fail;
16727 }
16728 {
16729 resultobj = SWIG_From_int((int)(result));
16730 }
16731 return resultobj;
16732 fail:
16733 return NULL;
16734 }
16735
16736
16737 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16738 PyObject *resultobj;
16739 wxDC *arg1 = (wxDC *) 0 ;
16740 int arg2 ;
16741 PyObject * obj0 = 0 ;
16742 PyObject * obj1 = 0 ;
16743 char *kwnames[] = {
16744 (char *) "self",(char *) "mode", NULL
16745 };
16746
16747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16749 if (SWIG_arg_fail(1)) SWIG_fail;
16750 {
16751 arg2 = (int)(SWIG_As_int(obj1));
16752 if (SWIG_arg_fail(2)) SWIG_fail;
16753 }
16754 {
16755 PyThreadState* __tstate = wxPyBeginAllowThreads();
16756 (arg1)->SetMapMode(arg2);
16757
16758 wxPyEndAllowThreads(__tstate);
16759 if (PyErr_Occurred()) SWIG_fail;
16760 }
16761 Py_INCREF(Py_None); resultobj = Py_None;
16762 return resultobj;
16763 fail:
16764 return NULL;
16765 }
16766
16767
16768 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16769 PyObject *resultobj;
16770 wxDC *arg1 = (wxDC *) 0 ;
16771 double *arg2 = (double *) 0 ;
16772 double *arg3 = (double *) 0 ;
16773 double temp2 ;
16774 int res2 = 0 ;
16775 double temp3 ;
16776 int res3 = 0 ;
16777 PyObject * obj0 = 0 ;
16778 char *kwnames[] = {
16779 (char *) "self", NULL
16780 };
16781
16782 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16783 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
16789 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16790
16791 wxPyEndAllowThreads(__tstate);
16792 if (PyErr_Occurred()) SWIG_fail;
16793 }
16794 Py_INCREF(Py_None); resultobj = Py_None;
16795 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16796 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16797 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16798 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16799 return resultobj;
16800 fail:
16801 return NULL;
16802 }
16803
16804
16805 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16806 PyObject *resultobj;
16807 wxDC *arg1 = (wxDC *) 0 ;
16808 double arg2 ;
16809 double arg3 ;
16810 PyObject * obj0 = 0 ;
16811 PyObject * obj1 = 0 ;
16812 PyObject * obj2 = 0 ;
16813 char *kwnames[] = {
16814 (char *) "self",(char *) "x",(char *) "y", NULL
16815 };
16816
16817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16819 if (SWIG_arg_fail(1)) SWIG_fail;
16820 {
16821 arg2 = (double)(SWIG_As_double(obj1));
16822 if (SWIG_arg_fail(2)) SWIG_fail;
16823 }
16824 {
16825 arg3 = (double)(SWIG_As_double(obj2));
16826 if (SWIG_arg_fail(3)) SWIG_fail;
16827 }
16828 {
16829 PyThreadState* __tstate = wxPyBeginAllowThreads();
16830 (arg1)->SetUserScale(arg2,arg3);
16831
16832 wxPyEndAllowThreads(__tstate);
16833 if (PyErr_Occurred()) SWIG_fail;
16834 }
16835 Py_INCREF(Py_None); resultobj = Py_None;
16836 return resultobj;
16837 fail:
16838 return NULL;
16839 }
16840
16841
16842 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16843 PyObject *resultobj;
16844 wxDC *arg1 = (wxDC *) 0 ;
16845 double *arg2 = (double *) 0 ;
16846 double *arg3 = (double *) 0 ;
16847 double temp2 ;
16848 int res2 = 0 ;
16849 double temp3 ;
16850 int res3 = 0 ;
16851 PyObject * obj0 = 0 ;
16852 char *kwnames[] = {
16853 (char *) "self", NULL
16854 };
16855
16856 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16857 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16860 if (SWIG_arg_fail(1)) SWIG_fail;
16861 {
16862 PyThreadState* __tstate = wxPyBeginAllowThreads();
16863 (arg1)->GetLogicalScale(arg2,arg3);
16864
16865 wxPyEndAllowThreads(__tstate);
16866 if (PyErr_Occurred()) SWIG_fail;
16867 }
16868 Py_INCREF(Py_None); resultobj = Py_None;
16869 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16870 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16871 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16872 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16873 return resultobj;
16874 fail:
16875 return NULL;
16876 }
16877
16878
16879 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16880 PyObject *resultobj;
16881 wxDC *arg1 = (wxDC *) 0 ;
16882 double arg2 ;
16883 double arg3 ;
16884 PyObject * obj0 = 0 ;
16885 PyObject * obj1 = 0 ;
16886 PyObject * obj2 = 0 ;
16887 char *kwnames[] = {
16888 (char *) "self",(char *) "x",(char *) "y", NULL
16889 };
16890
16891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16893 if (SWIG_arg_fail(1)) SWIG_fail;
16894 {
16895 arg2 = (double)(SWIG_As_double(obj1));
16896 if (SWIG_arg_fail(2)) SWIG_fail;
16897 }
16898 {
16899 arg3 = (double)(SWIG_As_double(obj2));
16900 if (SWIG_arg_fail(3)) SWIG_fail;
16901 }
16902 {
16903 PyThreadState* __tstate = wxPyBeginAllowThreads();
16904 (arg1)->SetLogicalScale(arg2,arg3);
16905
16906 wxPyEndAllowThreads(__tstate);
16907 if (PyErr_Occurred()) SWIG_fail;
16908 }
16909 Py_INCREF(Py_None); resultobj = Py_None;
16910 return resultobj;
16911 fail:
16912 return NULL;
16913 }
16914
16915
16916 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16917 PyObject *resultobj;
16918 wxDC *arg1 = (wxDC *) 0 ;
16919 wxPoint result;
16920 PyObject * obj0 = 0 ;
16921 char *kwnames[] = {
16922 (char *) "self", NULL
16923 };
16924
16925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16927 if (SWIG_arg_fail(1)) SWIG_fail;
16928 {
16929 PyThreadState* __tstate = wxPyBeginAllowThreads();
16930 result = ((wxDC const *)arg1)->GetLogicalOrigin();
16931
16932 wxPyEndAllowThreads(__tstate);
16933 if (PyErr_Occurred()) SWIG_fail;
16934 }
16935 {
16936 wxPoint * resultptr;
16937 resultptr = new wxPoint((wxPoint &)(result));
16938 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16939 }
16940 return resultobj;
16941 fail:
16942 return NULL;
16943 }
16944
16945
16946 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16947 PyObject *resultobj;
16948 wxDC *arg1 = (wxDC *) 0 ;
16949 int *arg2 = (int *) 0 ;
16950 int *arg3 = (int *) 0 ;
16951 int temp2 ;
16952 int res2 = 0 ;
16953 int temp3 ;
16954 int res3 = 0 ;
16955 PyObject * obj0 = 0 ;
16956 char *kwnames[] = {
16957 (char *) "self", NULL
16958 };
16959
16960 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16961 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
16963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16964 if (SWIG_arg_fail(1)) SWIG_fail;
16965 {
16966 PyThreadState* __tstate = wxPyBeginAllowThreads();
16967 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
16968
16969 wxPyEndAllowThreads(__tstate);
16970 if (PyErr_Occurred()) SWIG_fail;
16971 }
16972 Py_INCREF(Py_None); resultobj = Py_None;
16973 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16974 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16975 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16976 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16977 return resultobj;
16978 fail:
16979 return NULL;
16980 }
16981
16982
16983 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16984 PyObject *resultobj;
16985 wxDC *arg1 = (wxDC *) 0 ;
16986 int arg2 ;
16987 int arg3 ;
16988 PyObject * obj0 = 0 ;
16989 PyObject * obj1 = 0 ;
16990 PyObject * obj2 = 0 ;
16991 char *kwnames[] = {
16992 (char *) "self",(char *) "x",(char *) "y", NULL
16993 };
16994
16995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16997 if (SWIG_arg_fail(1)) SWIG_fail;
16998 {
16999 arg2 = (int)(SWIG_As_int(obj1));
17000 if (SWIG_arg_fail(2)) SWIG_fail;
17001 }
17002 {
17003 arg3 = (int)(SWIG_As_int(obj2));
17004 if (SWIG_arg_fail(3)) SWIG_fail;
17005 }
17006 {
17007 PyThreadState* __tstate = wxPyBeginAllowThreads();
17008 (arg1)->SetLogicalOrigin(arg2,arg3);
17009
17010 wxPyEndAllowThreads(__tstate);
17011 if (PyErr_Occurred()) SWIG_fail;
17012 }
17013 Py_INCREF(Py_None); resultobj = Py_None;
17014 return resultobj;
17015 fail:
17016 return NULL;
17017 }
17018
17019
17020 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17021 PyObject *resultobj;
17022 wxDC *arg1 = (wxDC *) 0 ;
17023 wxPoint *arg2 = 0 ;
17024 wxPoint temp2 ;
17025 PyObject * obj0 = 0 ;
17026 PyObject * obj1 = 0 ;
17027 char *kwnames[] = {
17028 (char *) "self",(char *) "point", NULL
17029 };
17030
17031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
17032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17033 if (SWIG_arg_fail(1)) SWIG_fail;
17034 {
17035 arg2 = &temp2;
17036 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17037 }
17038 {
17039 PyThreadState* __tstate = wxPyBeginAllowThreads();
17040 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
17041
17042 wxPyEndAllowThreads(__tstate);
17043 if (PyErr_Occurred()) SWIG_fail;
17044 }
17045 Py_INCREF(Py_None); resultobj = Py_None;
17046 return resultobj;
17047 fail:
17048 return NULL;
17049 }
17050
17051
17052 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17053 PyObject *resultobj;
17054 wxDC *arg1 = (wxDC *) 0 ;
17055 wxPoint result;
17056 PyObject * obj0 = 0 ;
17057 char *kwnames[] = {
17058 (char *) "self", NULL
17059 };
17060
17061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
17062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17063 if (SWIG_arg_fail(1)) SWIG_fail;
17064 {
17065 PyThreadState* __tstate = wxPyBeginAllowThreads();
17066 result = ((wxDC const *)arg1)->GetDeviceOrigin();
17067
17068 wxPyEndAllowThreads(__tstate);
17069 if (PyErr_Occurred()) SWIG_fail;
17070 }
17071 {
17072 wxPoint * resultptr;
17073 resultptr = new wxPoint((wxPoint &)(result));
17074 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17075 }
17076 return resultobj;
17077 fail:
17078 return NULL;
17079 }
17080
17081
17082 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17083 PyObject *resultobj;
17084 wxDC *arg1 = (wxDC *) 0 ;
17085 int *arg2 = (int *) 0 ;
17086 int *arg3 = (int *) 0 ;
17087 int temp2 ;
17088 int res2 = 0 ;
17089 int temp3 ;
17090 int res3 = 0 ;
17091 PyObject * obj0 = 0 ;
17092 char *kwnames[] = {
17093 (char *) "self", NULL
17094 };
17095
17096 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17097 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
17099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17100 if (SWIG_arg_fail(1)) SWIG_fail;
17101 {
17102 PyThreadState* __tstate = wxPyBeginAllowThreads();
17103 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
17104
17105 wxPyEndAllowThreads(__tstate);
17106 if (PyErr_Occurred()) SWIG_fail;
17107 }
17108 Py_INCREF(Py_None); resultobj = Py_None;
17109 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17110 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17111 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17112 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17113 return resultobj;
17114 fail:
17115 return NULL;
17116 }
17117
17118
17119 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17120 PyObject *resultobj;
17121 wxDC *arg1 = (wxDC *) 0 ;
17122 int arg2 ;
17123 int arg3 ;
17124 PyObject * obj0 = 0 ;
17125 PyObject * obj1 = 0 ;
17126 PyObject * obj2 = 0 ;
17127 char *kwnames[] = {
17128 (char *) "self",(char *) "x",(char *) "y", NULL
17129 };
17130
17131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
17132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17133 if (SWIG_arg_fail(1)) SWIG_fail;
17134 {
17135 arg2 = (int)(SWIG_As_int(obj1));
17136 if (SWIG_arg_fail(2)) SWIG_fail;
17137 }
17138 {
17139 arg3 = (int)(SWIG_As_int(obj2));
17140 if (SWIG_arg_fail(3)) SWIG_fail;
17141 }
17142 {
17143 PyThreadState* __tstate = wxPyBeginAllowThreads();
17144 (arg1)->SetDeviceOrigin(arg2,arg3);
17145
17146 wxPyEndAllowThreads(__tstate);
17147 if (PyErr_Occurred()) SWIG_fail;
17148 }
17149 Py_INCREF(Py_None); resultobj = Py_None;
17150 return resultobj;
17151 fail:
17152 return NULL;
17153 }
17154
17155
17156 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17157 PyObject *resultobj;
17158 wxDC *arg1 = (wxDC *) 0 ;
17159 wxPoint *arg2 = 0 ;
17160 wxPoint temp2 ;
17161 PyObject * obj0 = 0 ;
17162 PyObject * obj1 = 0 ;
17163 char *kwnames[] = {
17164 (char *) "self",(char *) "point", NULL
17165 };
17166
17167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
17168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17169 if (SWIG_arg_fail(1)) SWIG_fail;
17170 {
17171 arg2 = &temp2;
17172 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17173 }
17174 {
17175 PyThreadState* __tstate = wxPyBeginAllowThreads();
17176 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
17177
17178 wxPyEndAllowThreads(__tstate);
17179 if (PyErr_Occurred()) SWIG_fail;
17180 }
17181 Py_INCREF(Py_None); resultobj = Py_None;
17182 return resultobj;
17183 fail:
17184 return NULL;
17185 }
17186
17187
17188 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17189 PyObject *resultobj;
17190 wxDC *arg1 = (wxDC *) 0 ;
17191 bool arg2 ;
17192 bool arg3 ;
17193 PyObject * obj0 = 0 ;
17194 PyObject * obj1 = 0 ;
17195 PyObject * obj2 = 0 ;
17196 char *kwnames[] = {
17197 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
17198 };
17199
17200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
17201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17202 if (SWIG_arg_fail(1)) SWIG_fail;
17203 {
17204 arg2 = (bool)(SWIG_As_bool(obj1));
17205 if (SWIG_arg_fail(2)) SWIG_fail;
17206 }
17207 {
17208 arg3 = (bool)(SWIG_As_bool(obj2));
17209 if (SWIG_arg_fail(3)) SWIG_fail;
17210 }
17211 {
17212 PyThreadState* __tstate = wxPyBeginAllowThreads();
17213 (arg1)->SetAxisOrientation(arg2,arg3);
17214
17215 wxPyEndAllowThreads(__tstate);
17216 if (PyErr_Occurred()) SWIG_fail;
17217 }
17218 Py_INCREF(Py_None); resultobj = Py_None;
17219 return resultobj;
17220 fail:
17221 return NULL;
17222 }
17223
17224
17225 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
17226 PyObject *resultobj;
17227 wxDC *arg1 = (wxDC *) 0 ;
17228 int result;
17229 PyObject * obj0 = 0 ;
17230 char *kwnames[] = {
17231 (char *) "self", NULL
17232 };
17233
17234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
17235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17236 if (SWIG_arg_fail(1)) SWIG_fail;
17237 {
17238 PyThreadState* __tstate = wxPyBeginAllowThreads();
17239 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
17240
17241 wxPyEndAllowThreads(__tstate);
17242 if (PyErr_Occurred()) SWIG_fail;
17243 }
17244 {
17245 resultobj = SWIG_From_int((int)(result));
17246 }
17247 return resultobj;
17248 fail:
17249 return NULL;
17250 }
17251
17252
17253 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
17254 PyObject *resultobj;
17255 wxDC *arg1 = (wxDC *) 0 ;
17256 int arg2 ;
17257 PyObject * obj0 = 0 ;
17258 PyObject * obj1 = 0 ;
17259 char *kwnames[] = {
17260 (char *) "self",(char *) "function", NULL
17261 };
17262
17263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
17264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17265 if (SWIG_arg_fail(1)) SWIG_fail;
17266 {
17267 arg2 = (int)(SWIG_As_int(obj1));
17268 if (SWIG_arg_fail(2)) SWIG_fail;
17269 }
17270 {
17271 PyThreadState* __tstate = wxPyBeginAllowThreads();
17272 (arg1)->SetLogicalFunction(arg2);
17273
17274 wxPyEndAllowThreads(__tstate);
17275 if (PyErr_Occurred()) SWIG_fail;
17276 }
17277 Py_INCREF(Py_None); resultobj = Py_None;
17278 return resultobj;
17279 fail:
17280 return NULL;
17281 }
17282
17283
17284 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17285 PyObject *resultobj;
17286 wxDC *arg1 = (wxDC *) 0 ;
17287 PyObject * obj0 = 0 ;
17288 char *kwnames[] = {
17289 (char *) "self", NULL
17290 };
17291
17292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
17293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17294 if (SWIG_arg_fail(1)) SWIG_fail;
17295 {
17296 PyThreadState* __tstate = wxPyBeginAllowThreads();
17297 (arg1)->ComputeScaleAndOrigin();
17298
17299 wxPyEndAllowThreads(__tstate);
17300 if (PyErr_Occurred()) SWIG_fail;
17301 }
17302 Py_INCREF(Py_None); resultobj = Py_None;
17303 return resultobj;
17304 fail:
17305 return NULL;
17306 }
17307
17308
17309 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17310 PyObject *resultobj;
17311 wxDC *arg1 = (wxDC *) 0 ;
17312 int arg2 ;
17313 int arg3 ;
17314 PyObject * obj0 = 0 ;
17315 PyObject * obj1 = 0 ;
17316 PyObject * obj2 = 0 ;
17317 char *kwnames[] = {
17318 (char *) "self",(char *) "x",(char *) "y", NULL
17319 };
17320
17321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
17322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17323 if (SWIG_arg_fail(1)) SWIG_fail;
17324 {
17325 arg2 = (int)(SWIG_As_int(obj1));
17326 if (SWIG_arg_fail(2)) SWIG_fail;
17327 }
17328 {
17329 arg3 = (int)(SWIG_As_int(obj2));
17330 if (SWIG_arg_fail(3)) SWIG_fail;
17331 }
17332 {
17333 PyThreadState* __tstate = wxPyBeginAllowThreads();
17334 (arg1)->CalcBoundingBox(arg2,arg3);
17335
17336 wxPyEndAllowThreads(__tstate);
17337 if (PyErr_Occurred()) SWIG_fail;
17338 }
17339 Py_INCREF(Py_None); resultobj = Py_None;
17340 return resultobj;
17341 fail:
17342 return NULL;
17343 }
17344
17345
17346 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17347 PyObject *resultobj;
17348 wxDC *arg1 = (wxDC *) 0 ;
17349 wxPoint *arg2 = 0 ;
17350 wxPoint temp2 ;
17351 PyObject * obj0 = 0 ;
17352 PyObject * obj1 = 0 ;
17353 char *kwnames[] = {
17354 (char *) "self",(char *) "point", NULL
17355 };
17356
17357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
17358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17359 if (SWIG_arg_fail(1)) SWIG_fail;
17360 {
17361 arg2 = &temp2;
17362 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17363 }
17364 {
17365 PyThreadState* __tstate = wxPyBeginAllowThreads();
17366 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
17367
17368 wxPyEndAllowThreads(__tstate);
17369 if (PyErr_Occurred()) SWIG_fail;
17370 }
17371 Py_INCREF(Py_None); resultobj = Py_None;
17372 return resultobj;
17373 fail:
17374 return NULL;
17375 }
17376
17377
17378 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17379 PyObject *resultobj;
17380 wxDC *arg1 = (wxDC *) 0 ;
17381 PyObject * obj0 = 0 ;
17382 char *kwnames[] = {
17383 (char *) "self", NULL
17384 };
17385
17386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
17387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17388 if (SWIG_arg_fail(1)) SWIG_fail;
17389 {
17390 PyThreadState* __tstate = wxPyBeginAllowThreads();
17391 (arg1)->ResetBoundingBox();
17392
17393 wxPyEndAllowThreads(__tstate);
17394 if (PyErr_Occurred()) SWIG_fail;
17395 }
17396 Py_INCREF(Py_None); resultobj = Py_None;
17397 return resultobj;
17398 fail:
17399 return NULL;
17400 }
17401
17402
17403 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
17404 PyObject *resultobj;
17405 wxDC *arg1 = (wxDC *) 0 ;
17406 int result;
17407 PyObject * obj0 = 0 ;
17408 char *kwnames[] = {
17409 (char *) "self", NULL
17410 };
17411
17412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
17413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17414 if (SWIG_arg_fail(1)) SWIG_fail;
17415 {
17416 PyThreadState* __tstate = wxPyBeginAllowThreads();
17417 result = (int)((wxDC const *)arg1)->MinX();
17418
17419 wxPyEndAllowThreads(__tstate);
17420 if (PyErr_Occurred()) SWIG_fail;
17421 }
17422 {
17423 resultobj = SWIG_From_int((int)(result));
17424 }
17425 return resultobj;
17426 fail:
17427 return NULL;
17428 }
17429
17430
17431 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
17432 PyObject *resultobj;
17433 wxDC *arg1 = (wxDC *) 0 ;
17434 int result;
17435 PyObject * obj0 = 0 ;
17436 char *kwnames[] = {
17437 (char *) "self", NULL
17438 };
17439
17440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
17441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17442 if (SWIG_arg_fail(1)) SWIG_fail;
17443 {
17444 PyThreadState* __tstate = wxPyBeginAllowThreads();
17445 result = (int)((wxDC const *)arg1)->MaxX();
17446
17447 wxPyEndAllowThreads(__tstate);
17448 if (PyErr_Occurred()) SWIG_fail;
17449 }
17450 {
17451 resultobj = SWIG_From_int((int)(result));
17452 }
17453 return resultobj;
17454 fail:
17455 return NULL;
17456 }
17457
17458
17459 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
17460 PyObject *resultobj;
17461 wxDC *arg1 = (wxDC *) 0 ;
17462 int result;
17463 PyObject * obj0 = 0 ;
17464 char *kwnames[] = {
17465 (char *) "self", NULL
17466 };
17467
17468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
17469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17470 if (SWIG_arg_fail(1)) SWIG_fail;
17471 {
17472 PyThreadState* __tstate = wxPyBeginAllowThreads();
17473 result = (int)((wxDC const *)arg1)->MinY();
17474
17475 wxPyEndAllowThreads(__tstate);
17476 if (PyErr_Occurred()) SWIG_fail;
17477 }
17478 {
17479 resultobj = SWIG_From_int((int)(result));
17480 }
17481 return resultobj;
17482 fail:
17483 return NULL;
17484 }
17485
17486
17487 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
17488 PyObject *resultobj;
17489 wxDC *arg1 = (wxDC *) 0 ;
17490 int result;
17491 PyObject * obj0 = 0 ;
17492 char *kwnames[] = {
17493 (char *) "self", NULL
17494 };
17495
17496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
17497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17498 if (SWIG_arg_fail(1)) SWIG_fail;
17499 {
17500 PyThreadState* __tstate = wxPyBeginAllowThreads();
17501 result = (int)((wxDC const *)arg1)->MaxY();
17502
17503 wxPyEndAllowThreads(__tstate);
17504 if (PyErr_Occurred()) SWIG_fail;
17505 }
17506 {
17507 resultobj = SWIG_From_int((int)(result));
17508 }
17509 return resultobj;
17510 fail:
17511 return NULL;
17512 }
17513
17514
17515 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17516 PyObject *resultobj;
17517 wxDC *arg1 = (wxDC *) 0 ;
17518 int *arg2 = (int *) 0 ;
17519 int *arg3 = (int *) 0 ;
17520 int *arg4 = (int *) 0 ;
17521 int *arg5 = (int *) 0 ;
17522 int temp2 ;
17523 int res2 = 0 ;
17524 int temp3 ;
17525 int res3 = 0 ;
17526 int temp4 ;
17527 int res4 = 0 ;
17528 int temp5 ;
17529 int res5 = 0 ;
17530 PyObject * obj0 = 0 ;
17531 char *kwnames[] = {
17532 (char *) "self", NULL
17533 };
17534
17535 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17536 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17537 arg4 = &temp4; res4 = SWIG_NEWOBJ;
17538 arg5 = &temp5; res5 = SWIG_NEWOBJ;
17539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
17540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17541 if (SWIG_arg_fail(1)) SWIG_fail;
17542 {
17543 PyThreadState* __tstate = wxPyBeginAllowThreads();
17544 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
17545
17546 wxPyEndAllowThreads(__tstate);
17547 if (PyErr_Occurred()) SWIG_fail;
17548 }
17549 Py_INCREF(Py_None); resultobj = Py_None;
17550 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17551 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17552 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17553 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17554 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
17555 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
17556 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
17557 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
17558 return resultobj;
17559 fail:
17560 return NULL;
17561 }
17562
17563
17564 static PyObject *_wrap_DC_GetHDC(PyObject *, PyObject *args, PyObject *kwargs) {
17565 PyObject *resultobj;
17566 wxDC *arg1 = (wxDC *) 0 ;
17567 long result;
17568 PyObject * obj0 = 0 ;
17569 char *kwnames[] = {
17570 (char *) "self", NULL
17571 };
17572
17573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetHDC",kwnames,&obj0)) goto fail;
17574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17575 if (SWIG_arg_fail(1)) SWIG_fail;
17576 {
17577 PyThreadState* __tstate = wxPyBeginAllowThreads();
17578 result = (long)(arg1)->GetHDC();
17579
17580 wxPyEndAllowThreads(__tstate);
17581 if (PyErr_Occurred()) SWIG_fail;
17582 }
17583 {
17584 resultobj = SWIG_From_long((long)(result));
17585 }
17586 return resultobj;
17587 fail:
17588 return NULL;
17589 }
17590
17591
17592 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
17593 PyObject *resultobj;
17594 wxDC *arg1 = (wxDC *) 0 ;
17595 PyObject *arg2 = (PyObject *) 0 ;
17596 PyObject *arg3 = (PyObject *) 0 ;
17597 PyObject *arg4 = (PyObject *) 0 ;
17598 PyObject *result;
17599 PyObject * obj0 = 0 ;
17600 PyObject * obj1 = 0 ;
17601 PyObject * obj2 = 0 ;
17602 PyObject * obj3 = 0 ;
17603 char *kwnames[] = {
17604 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17605 };
17606
17607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17609 if (SWIG_arg_fail(1)) SWIG_fail;
17610 arg2 = obj1;
17611 arg3 = obj2;
17612 arg4 = obj3;
17613 {
17614 PyThreadState* __tstate = wxPyBeginAllowThreads();
17615 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
17616
17617 wxPyEndAllowThreads(__tstate);
17618 if (PyErr_Occurred()) SWIG_fail;
17619 }
17620 resultobj = result;
17621 return resultobj;
17622 fail:
17623 return NULL;
17624 }
17625
17626
17627 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
17628 PyObject *resultobj;
17629 wxDC *arg1 = (wxDC *) 0 ;
17630 PyObject *arg2 = (PyObject *) 0 ;
17631 PyObject *arg3 = (PyObject *) 0 ;
17632 PyObject *arg4 = (PyObject *) 0 ;
17633 PyObject *result;
17634 PyObject * obj0 = 0 ;
17635 PyObject * obj1 = 0 ;
17636 PyObject * obj2 = 0 ;
17637 PyObject * obj3 = 0 ;
17638 char *kwnames[] = {
17639 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17640 };
17641
17642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17644 if (SWIG_arg_fail(1)) SWIG_fail;
17645 arg2 = obj1;
17646 arg3 = obj2;
17647 arg4 = obj3;
17648 {
17649 PyThreadState* __tstate = wxPyBeginAllowThreads();
17650 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
17651
17652 wxPyEndAllowThreads(__tstate);
17653 if (PyErr_Occurred()) SWIG_fail;
17654 }
17655 resultobj = result;
17656 return resultobj;
17657 fail:
17658 return NULL;
17659 }
17660
17661
17662 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
17663 PyObject *resultobj;
17664 wxDC *arg1 = (wxDC *) 0 ;
17665 PyObject *arg2 = (PyObject *) 0 ;
17666 PyObject *arg3 = (PyObject *) 0 ;
17667 PyObject *arg4 = (PyObject *) 0 ;
17668 PyObject *result;
17669 PyObject * obj0 = 0 ;
17670 PyObject * obj1 = 0 ;
17671 PyObject * obj2 = 0 ;
17672 PyObject * obj3 = 0 ;
17673 char *kwnames[] = {
17674 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17675 };
17676
17677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17679 if (SWIG_arg_fail(1)) SWIG_fail;
17680 arg2 = obj1;
17681 arg3 = obj2;
17682 arg4 = obj3;
17683 {
17684 PyThreadState* __tstate = wxPyBeginAllowThreads();
17685 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17686
17687 wxPyEndAllowThreads(__tstate);
17688 if (PyErr_Occurred()) SWIG_fail;
17689 }
17690 resultobj = result;
17691 return resultobj;
17692 fail:
17693 return NULL;
17694 }
17695
17696
17697 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17698 PyObject *resultobj;
17699 wxDC *arg1 = (wxDC *) 0 ;
17700 PyObject *arg2 = (PyObject *) 0 ;
17701 PyObject *arg3 = (PyObject *) 0 ;
17702 PyObject *arg4 = (PyObject *) 0 ;
17703 PyObject *result;
17704 PyObject * obj0 = 0 ;
17705 PyObject * obj1 = 0 ;
17706 PyObject * obj2 = 0 ;
17707 PyObject * obj3 = 0 ;
17708 char *kwnames[] = {
17709 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17710 };
17711
17712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17714 if (SWIG_arg_fail(1)) SWIG_fail;
17715 arg2 = obj1;
17716 arg3 = obj2;
17717 arg4 = obj3;
17718 {
17719 PyThreadState* __tstate = wxPyBeginAllowThreads();
17720 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17721
17722 wxPyEndAllowThreads(__tstate);
17723 if (PyErr_Occurred()) SWIG_fail;
17724 }
17725 resultobj = result;
17726 return resultobj;
17727 fail:
17728 return NULL;
17729 }
17730
17731
17732 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17733 PyObject *resultobj;
17734 wxDC *arg1 = (wxDC *) 0 ;
17735 PyObject *arg2 = (PyObject *) 0 ;
17736 PyObject *arg3 = (PyObject *) 0 ;
17737 PyObject *arg4 = (PyObject *) 0 ;
17738 PyObject *result;
17739 PyObject * obj0 = 0 ;
17740 PyObject * obj1 = 0 ;
17741 PyObject * obj2 = 0 ;
17742 PyObject * obj3 = 0 ;
17743 char *kwnames[] = {
17744 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17745 };
17746
17747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17749 if (SWIG_arg_fail(1)) SWIG_fail;
17750 arg2 = obj1;
17751 arg3 = obj2;
17752 arg4 = obj3;
17753 {
17754 PyThreadState* __tstate = wxPyBeginAllowThreads();
17755 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17756
17757 wxPyEndAllowThreads(__tstate);
17758 if (PyErr_Occurred()) SWIG_fail;
17759 }
17760 resultobj = result;
17761 return resultobj;
17762 fail:
17763 return NULL;
17764 }
17765
17766
17767 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17768 PyObject *resultobj;
17769 wxDC *arg1 = (wxDC *) 0 ;
17770 PyObject *arg2 = (PyObject *) 0 ;
17771 PyObject *arg3 = (PyObject *) 0 ;
17772 PyObject *arg4 = (PyObject *) 0 ;
17773 PyObject *arg5 = (PyObject *) 0 ;
17774 PyObject *result;
17775 PyObject * obj0 = 0 ;
17776 PyObject * obj1 = 0 ;
17777 PyObject * obj2 = 0 ;
17778 PyObject * obj3 = 0 ;
17779 PyObject * obj4 = 0 ;
17780 char *kwnames[] = {
17781 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17782 };
17783
17784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17786 if (SWIG_arg_fail(1)) SWIG_fail;
17787 arg2 = obj1;
17788 arg3 = obj2;
17789 arg4 = obj3;
17790 arg5 = obj4;
17791 {
17792 PyThreadState* __tstate = wxPyBeginAllowThreads();
17793 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17794
17795 wxPyEndAllowThreads(__tstate);
17796 if (PyErr_Occurred()) SWIG_fail;
17797 }
17798 resultobj = result;
17799 return resultobj;
17800 fail:
17801 return NULL;
17802 }
17803
17804
17805 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17806 PyObject *obj;
17807 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17808 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17809 Py_INCREF(obj);
17810 return Py_BuildValue((char *)"");
17811 }
17812 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17813 PyObject *resultobj;
17814 wxMemoryDC *result;
17815 char *kwnames[] = {
17816 NULL
17817 };
17818
17819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17820 {
17821 if (!wxPyCheckForApp()) SWIG_fail;
17822 PyThreadState* __tstate = wxPyBeginAllowThreads();
17823 result = (wxMemoryDC *)new wxMemoryDC();
17824
17825 wxPyEndAllowThreads(__tstate);
17826 if (PyErr_Occurred()) SWIG_fail;
17827 }
17828 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17829 return resultobj;
17830 fail:
17831 return NULL;
17832 }
17833
17834
17835 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17836 PyObject *resultobj;
17837 wxDC *arg1 = (wxDC *) 0 ;
17838 wxMemoryDC *result;
17839 PyObject * obj0 = 0 ;
17840 char *kwnames[] = {
17841 (char *) "oldDC", NULL
17842 };
17843
17844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17846 if (SWIG_arg_fail(1)) SWIG_fail;
17847 {
17848 if (!wxPyCheckForApp()) SWIG_fail;
17849 PyThreadState* __tstate = wxPyBeginAllowThreads();
17850 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17851
17852 wxPyEndAllowThreads(__tstate);
17853 if (PyErr_Occurred()) SWIG_fail;
17854 }
17855 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17856 return resultobj;
17857 fail:
17858 return NULL;
17859 }
17860
17861
17862 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17863 PyObject *resultobj;
17864 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17865 wxBitmap *arg2 = 0 ;
17866 PyObject * obj0 = 0 ;
17867 PyObject * obj1 = 0 ;
17868 char *kwnames[] = {
17869 (char *) "self",(char *) "bitmap", NULL
17870 };
17871
17872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17874 if (SWIG_arg_fail(1)) SWIG_fail;
17875 {
17876 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17877 if (SWIG_arg_fail(2)) SWIG_fail;
17878 if (arg2 == NULL) {
17879 SWIG_null_ref("wxBitmap");
17880 }
17881 if (SWIG_arg_fail(2)) SWIG_fail;
17882 }
17883 {
17884 PyThreadState* __tstate = wxPyBeginAllowThreads();
17885 (arg1)->SelectObject((wxBitmap const &)*arg2);
17886
17887 wxPyEndAllowThreads(__tstate);
17888 if (PyErr_Occurred()) SWIG_fail;
17889 }
17890 Py_INCREF(Py_None); resultobj = Py_None;
17891 return resultobj;
17892 fail:
17893 return NULL;
17894 }
17895
17896
17897 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17898 PyObject *obj;
17899 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17900 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17901 Py_INCREF(obj);
17902 return Py_BuildValue((char *)"");
17903 }
17904 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17905 PyObject *resultobj;
17906 wxDC *arg1 = (wxDC *) 0 ;
17907 wxBitmap *arg2 = 0 ;
17908 wxBufferedDC *result;
17909 PyObject * obj0 = 0 ;
17910 PyObject * obj1 = 0 ;
17911
17912 if(!PyArg_ParseTuple(args,(char *)"OO:new_BufferedDC",&obj0,&obj1)) goto fail;
17913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17914 if (SWIG_arg_fail(1)) SWIG_fail;
17915 {
17916 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17917 if (SWIG_arg_fail(2)) SWIG_fail;
17918 if (arg2 == NULL) {
17919 SWIG_null_ref("wxBitmap");
17920 }
17921 if (SWIG_arg_fail(2)) SWIG_fail;
17922 }
17923 {
17924 if (!wxPyCheckForApp()) SWIG_fail;
17925 PyThreadState* __tstate = wxPyBeginAllowThreads();
17926 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2);
17927
17928 wxPyEndAllowThreads(__tstate);
17929 if (PyErr_Occurred()) SWIG_fail;
17930 }
17931 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17932 return resultobj;
17933 fail:
17934 return NULL;
17935 }
17936
17937
17938 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17939 PyObject *resultobj;
17940 wxDC *arg1 = (wxDC *) 0 ;
17941 wxSize *arg2 = 0 ;
17942 wxBufferedDC *result;
17943 wxSize temp2 ;
17944 PyObject * obj0 = 0 ;
17945 PyObject * obj1 = 0 ;
17946
17947 if(!PyArg_ParseTuple(args,(char *)"OO:new_BufferedDC",&obj0,&obj1)) goto fail;
17948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17949 if (SWIG_arg_fail(1)) SWIG_fail;
17950 {
17951 arg2 = &temp2;
17952 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17953 }
17954 {
17955 if (!wxPyCheckForApp()) SWIG_fail;
17956 PyThreadState* __tstate = wxPyBeginAllowThreads();
17957 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2);
17958
17959 wxPyEndAllowThreads(__tstate);
17960 if (PyErr_Occurred()) SWIG_fail;
17961 }
17962 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17963 return resultobj;
17964 fail:
17965 return NULL;
17966 }
17967
17968
17969 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
17970 int argc;
17971 PyObject *argv[3];
17972 int ii;
17973
17974 argc = PyObject_Length(args);
17975 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
17976 argv[ii] = PyTuple_GetItem(args,ii);
17977 }
17978 if (argc == 2) {
17979 int _v;
17980 {
17981 void *ptr;
17982 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17983 _v = 0;
17984 PyErr_Clear();
17985 } else {
17986 _v = 1;
17987 }
17988 }
17989 if (_v) {
17990 {
17991 void *ptr = 0;
17992 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
17993 _v = 0;
17994 PyErr_Clear();
17995 } else {
17996 _v = (ptr != 0);
17997 }
17998 }
17999 if (_v) {
18000 return _wrap_new_BufferedDC__SWIG_0(self,args);
18001 }
18002 }
18003 }
18004 if (argc == 2) {
18005 int _v;
18006 {
18007 void *ptr;
18008 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
18009 _v = 0;
18010 PyErr_Clear();
18011 } else {
18012 _v = 1;
18013 }
18014 }
18015 if (_v) {
18016 {
18017 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
18018 }
18019 if (_v) {
18020 return _wrap_new_BufferedDC__SWIG_1(self,args);
18021 }
18022 }
18023 }
18024
18025 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
18026 return NULL;
18027 }
18028
18029
18030 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
18031 PyObject *resultobj;
18032 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
18033 PyObject * obj0 = 0 ;
18034 char *kwnames[] = {
18035 (char *) "self", NULL
18036 };
18037
18038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
18039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
18040 if (SWIG_arg_fail(1)) SWIG_fail;
18041 {
18042 PyThreadState* __tstate = wxPyBeginAllowThreads();
18043 delete arg1;
18044
18045 wxPyEndAllowThreads(__tstate);
18046 if (PyErr_Occurred()) SWIG_fail;
18047 }
18048 Py_INCREF(Py_None); resultobj = Py_None;
18049 return resultobj;
18050 fail:
18051 return NULL;
18052 }
18053
18054
18055 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
18056 PyObject *resultobj;
18057 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
18058 PyObject * obj0 = 0 ;
18059 char *kwnames[] = {
18060 (char *) "self", NULL
18061 };
18062
18063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
18064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
18065 if (SWIG_arg_fail(1)) SWIG_fail;
18066 {
18067 PyThreadState* __tstate = wxPyBeginAllowThreads();
18068 (arg1)->UnMask();
18069
18070 wxPyEndAllowThreads(__tstate);
18071 if (PyErr_Occurred()) SWIG_fail;
18072 }
18073 Py_INCREF(Py_None); resultobj = Py_None;
18074 return resultobj;
18075 fail:
18076 return NULL;
18077 }
18078
18079
18080 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
18081 PyObject *obj;
18082 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18083 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
18084 Py_INCREF(obj);
18085 return Py_BuildValue((char *)"");
18086 }
18087 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
18088 PyObject *resultobj;
18089 wxWindow *arg1 = (wxWindow *) 0 ;
18090 wxBitmap const &arg2_defvalue = wxNullBitmap ;
18091 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
18092 wxBufferedPaintDC *result;
18093 PyObject * obj0 = 0 ;
18094 PyObject * obj1 = 0 ;
18095 char *kwnames[] = {
18096 (char *) "window",(char *) "buffer", NULL
18097 };
18098
18099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BufferedPaintDC",kwnames,&obj0,&obj1)) goto fail;
18100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18101 if (SWIG_arg_fail(1)) SWIG_fail;
18102 if (obj1) {
18103 {
18104 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18105 if (SWIG_arg_fail(2)) SWIG_fail;
18106 if (arg2 == NULL) {
18107 SWIG_null_ref("wxBitmap");
18108 }
18109 if (SWIG_arg_fail(2)) SWIG_fail;
18110 }
18111 }
18112 {
18113 if (!wxPyCheckForApp()) SWIG_fail;
18114 PyThreadState* __tstate = wxPyBeginAllowThreads();
18115 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2);
18116
18117 wxPyEndAllowThreads(__tstate);
18118 if (PyErr_Occurred()) SWIG_fail;
18119 }
18120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
18121 return resultobj;
18122 fail:
18123 return NULL;
18124 }
18125
18126
18127 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
18128 PyObject *obj;
18129 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18130 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
18131 Py_INCREF(obj);
18132 return Py_BuildValue((char *)"");
18133 }
18134 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
18135 PyObject *resultobj;
18136 wxScreenDC *result;
18137 char *kwnames[] = {
18138 NULL
18139 };
18140
18141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
18142 {
18143 if (!wxPyCheckForApp()) SWIG_fail;
18144 PyThreadState* __tstate = wxPyBeginAllowThreads();
18145 result = (wxScreenDC *)new wxScreenDC();
18146
18147 wxPyEndAllowThreads(__tstate);
18148 if (PyErr_Occurred()) SWIG_fail;
18149 }
18150 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
18151 return resultobj;
18152 fail:
18153 return NULL;
18154 }
18155
18156
18157 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
18158 PyObject *resultobj;
18159 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18160 wxWindow *arg2 = (wxWindow *) 0 ;
18161 bool result;
18162 PyObject * obj0 = 0 ;
18163 PyObject * obj1 = 0 ;
18164 char *kwnames[] = {
18165 (char *) "self",(char *) "window", NULL
18166 };
18167
18168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
18169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18170 if (SWIG_arg_fail(1)) SWIG_fail;
18171 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18172 if (SWIG_arg_fail(2)) SWIG_fail;
18173 {
18174 PyThreadState* __tstate = wxPyBeginAllowThreads();
18175 result = (bool)(arg1)->StartDrawingOnTop(arg2);
18176
18177 wxPyEndAllowThreads(__tstate);
18178 if (PyErr_Occurred()) SWIG_fail;
18179 }
18180 {
18181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18182 }
18183 return resultobj;
18184 fail:
18185 return NULL;
18186 }
18187
18188
18189 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
18190 PyObject *resultobj;
18191 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18192 wxRect *arg2 = (wxRect *) NULL ;
18193 bool result;
18194 PyObject * obj0 = 0 ;
18195 PyObject * obj1 = 0 ;
18196 char *kwnames[] = {
18197 (char *) "self",(char *) "rect", NULL
18198 };
18199
18200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
18201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18202 if (SWIG_arg_fail(1)) SWIG_fail;
18203 if (obj1) {
18204 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18205 if (SWIG_arg_fail(2)) SWIG_fail;
18206 }
18207 {
18208 PyThreadState* __tstate = wxPyBeginAllowThreads();
18209 result = (bool)(arg1)->StartDrawingOnTop(arg2);
18210
18211 wxPyEndAllowThreads(__tstate);
18212 if (PyErr_Occurred()) SWIG_fail;
18213 }
18214 {
18215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18216 }
18217 return resultobj;
18218 fail:
18219 return NULL;
18220 }
18221
18222
18223 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
18224 PyObject *resultobj;
18225 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18226 bool result;
18227 PyObject * obj0 = 0 ;
18228 char *kwnames[] = {
18229 (char *) "self", NULL
18230 };
18231
18232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
18233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18234 if (SWIG_arg_fail(1)) SWIG_fail;
18235 {
18236 PyThreadState* __tstate = wxPyBeginAllowThreads();
18237 result = (bool)(arg1)->EndDrawingOnTop();
18238
18239 wxPyEndAllowThreads(__tstate);
18240 if (PyErr_Occurred()) SWIG_fail;
18241 }
18242 {
18243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18244 }
18245 return resultobj;
18246 fail:
18247 return NULL;
18248 }
18249
18250
18251 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
18252 PyObject *obj;
18253 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18254 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
18255 Py_INCREF(obj);
18256 return Py_BuildValue((char *)"");
18257 }
18258 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
18259 PyObject *resultobj;
18260 wxWindow *arg1 = (wxWindow *) 0 ;
18261 wxClientDC *result;
18262 PyObject * obj0 = 0 ;
18263 char *kwnames[] = {
18264 (char *) "win", NULL
18265 };
18266
18267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
18268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18269 if (SWIG_arg_fail(1)) SWIG_fail;
18270 {
18271 if (!wxPyCheckForApp()) SWIG_fail;
18272 PyThreadState* __tstate = wxPyBeginAllowThreads();
18273 result = (wxClientDC *)new wxClientDC(arg1);
18274
18275 wxPyEndAllowThreads(__tstate);
18276 if (PyErr_Occurred()) SWIG_fail;
18277 }
18278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
18279 return resultobj;
18280 fail:
18281 return NULL;
18282 }
18283
18284
18285 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
18286 PyObject *obj;
18287 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18288 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
18289 Py_INCREF(obj);
18290 return Py_BuildValue((char *)"");
18291 }
18292 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
18293 PyObject *resultobj;
18294 wxWindow *arg1 = (wxWindow *) 0 ;
18295 wxPaintDC *result;
18296 PyObject * obj0 = 0 ;
18297 char *kwnames[] = {
18298 (char *) "win", NULL
18299 };
18300
18301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
18302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18303 if (SWIG_arg_fail(1)) SWIG_fail;
18304 {
18305 if (!wxPyCheckForApp()) SWIG_fail;
18306 PyThreadState* __tstate = wxPyBeginAllowThreads();
18307 result = (wxPaintDC *)new wxPaintDC(arg1);
18308
18309 wxPyEndAllowThreads(__tstate);
18310 if (PyErr_Occurred()) SWIG_fail;
18311 }
18312 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
18313 return resultobj;
18314 fail:
18315 return NULL;
18316 }
18317
18318
18319 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
18320 PyObject *obj;
18321 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18322 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
18323 Py_INCREF(obj);
18324 return Py_BuildValue((char *)"");
18325 }
18326 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
18327 PyObject *resultobj;
18328 wxWindow *arg1 = (wxWindow *) 0 ;
18329 wxWindowDC *result;
18330 PyObject * obj0 = 0 ;
18331 char *kwnames[] = {
18332 (char *) "win", NULL
18333 };
18334
18335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
18336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18337 if (SWIG_arg_fail(1)) SWIG_fail;
18338 {
18339 if (!wxPyCheckForApp()) SWIG_fail;
18340 PyThreadState* __tstate = wxPyBeginAllowThreads();
18341 result = (wxWindowDC *)new wxWindowDC(arg1);
18342
18343 wxPyEndAllowThreads(__tstate);
18344 if (PyErr_Occurred()) SWIG_fail;
18345 }
18346 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
18347 return resultobj;
18348 fail:
18349 return NULL;
18350 }
18351
18352
18353 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
18354 PyObject *obj;
18355 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18356 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
18357 Py_INCREF(obj);
18358 return Py_BuildValue((char *)"");
18359 }
18360 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
18361 PyObject *resultobj;
18362 wxDC *arg1 = 0 ;
18363 bool arg2 ;
18364 wxMirrorDC *result;
18365 PyObject * obj0 = 0 ;
18366 PyObject * obj1 = 0 ;
18367 char *kwnames[] = {
18368 (char *) "dc",(char *) "mirror", NULL
18369 };
18370
18371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
18372 {
18373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18374 if (SWIG_arg_fail(1)) SWIG_fail;
18375 if (arg1 == NULL) {
18376 SWIG_null_ref("wxDC");
18377 }
18378 if (SWIG_arg_fail(1)) SWIG_fail;
18379 }
18380 {
18381 arg2 = (bool)(SWIG_As_bool(obj1));
18382 if (SWIG_arg_fail(2)) SWIG_fail;
18383 }
18384 {
18385 if (!wxPyCheckForApp()) SWIG_fail;
18386 PyThreadState* __tstate = wxPyBeginAllowThreads();
18387 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
18388
18389 wxPyEndAllowThreads(__tstate);
18390 if (PyErr_Occurred()) SWIG_fail;
18391 }
18392 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
18393 return resultobj;
18394 fail:
18395 return NULL;
18396 }
18397
18398
18399 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
18400 PyObject *obj;
18401 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18402 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
18403 Py_INCREF(obj);
18404 return Py_BuildValue((char *)"");
18405 }
18406 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
18407 PyObject *resultobj;
18408 wxPrintData *arg1 = 0 ;
18409 wxPostScriptDC *result;
18410 PyObject * obj0 = 0 ;
18411 char *kwnames[] = {
18412 (char *) "printData", NULL
18413 };
18414
18415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
18416 {
18417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18418 if (SWIG_arg_fail(1)) SWIG_fail;
18419 if (arg1 == NULL) {
18420 SWIG_null_ref("wxPrintData");
18421 }
18422 if (SWIG_arg_fail(1)) SWIG_fail;
18423 }
18424 {
18425 if (!wxPyCheckForApp()) SWIG_fail;
18426 PyThreadState* __tstate = wxPyBeginAllowThreads();
18427 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
18428
18429 wxPyEndAllowThreads(__tstate);
18430 if (PyErr_Occurred()) SWIG_fail;
18431 }
18432 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
18433 return resultobj;
18434 fail:
18435 return NULL;
18436 }
18437
18438
18439 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
18440 PyObject *resultobj;
18441 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
18442 wxPrintData *result;
18443 PyObject * obj0 = 0 ;
18444 char *kwnames[] = {
18445 (char *) "self", NULL
18446 };
18447
18448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
18449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
18450 if (SWIG_arg_fail(1)) SWIG_fail;
18451 {
18452 PyThreadState* __tstate = wxPyBeginAllowThreads();
18453 {
18454 wxPrintData &_result_ref = (arg1)->GetPrintData();
18455 result = (wxPrintData *) &_result_ref;
18456 }
18457
18458 wxPyEndAllowThreads(__tstate);
18459 if (PyErr_Occurred()) SWIG_fail;
18460 }
18461 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
18462 return resultobj;
18463 fail:
18464 return NULL;
18465 }
18466
18467
18468 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
18469 PyObject *resultobj;
18470 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
18471 wxPrintData *arg2 = 0 ;
18472 PyObject * obj0 = 0 ;
18473 PyObject * obj1 = 0 ;
18474 char *kwnames[] = {
18475 (char *) "self",(char *) "data", NULL
18476 };
18477
18478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
18479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
18480 if (SWIG_arg_fail(1)) SWIG_fail;
18481 {
18482 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18483 if (SWIG_arg_fail(2)) SWIG_fail;
18484 if (arg2 == NULL) {
18485 SWIG_null_ref("wxPrintData");
18486 }
18487 if (SWIG_arg_fail(2)) SWIG_fail;
18488 }
18489 {
18490 PyThreadState* __tstate = wxPyBeginAllowThreads();
18491 (arg1)->SetPrintData((wxPrintData const &)*arg2);
18492
18493 wxPyEndAllowThreads(__tstate);
18494 if (PyErr_Occurred()) SWIG_fail;
18495 }
18496 Py_INCREF(Py_None); resultobj = Py_None;
18497 return resultobj;
18498 fail:
18499 return NULL;
18500 }
18501
18502
18503 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
18504 PyObject *resultobj;
18505 int arg1 ;
18506 PyObject * obj0 = 0 ;
18507 char *kwnames[] = {
18508 (char *) "ppi", NULL
18509 };
18510
18511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
18512 {
18513 arg1 = (int)(SWIG_As_int(obj0));
18514 if (SWIG_arg_fail(1)) SWIG_fail;
18515 }
18516 {
18517 PyThreadState* __tstate = wxPyBeginAllowThreads();
18518 wxPostScriptDC::SetResolution(arg1);
18519
18520 wxPyEndAllowThreads(__tstate);
18521 if (PyErr_Occurred()) SWIG_fail;
18522 }
18523 Py_INCREF(Py_None); resultobj = Py_None;
18524 return resultobj;
18525 fail:
18526 return NULL;
18527 }
18528
18529
18530 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
18531 PyObject *resultobj;
18532 int result;
18533 char *kwnames[] = {
18534 NULL
18535 };
18536
18537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
18538 {
18539 PyThreadState* __tstate = wxPyBeginAllowThreads();
18540 result = (int)wxPostScriptDC::GetResolution();
18541
18542 wxPyEndAllowThreads(__tstate);
18543 if (PyErr_Occurred()) SWIG_fail;
18544 }
18545 {
18546 resultobj = SWIG_From_int((int)(result));
18547 }
18548 return resultobj;
18549 fail:
18550 return NULL;
18551 }
18552
18553
18554 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
18555 PyObject *obj;
18556 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18557 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
18558 Py_INCREF(obj);
18559 return Py_BuildValue((char *)"");
18560 }
18561 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18562 PyObject *resultobj;
18563 wxString const &arg1_defvalue = wxPyEmptyString ;
18564 wxString *arg1 = (wxString *) &arg1_defvalue ;
18565 wxMetaFile *result;
18566 bool temp1 = false ;
18567 PyObject * obj0 = 0 ;
18568 char *kwnames[] = {
18569 (char *) "filename", NULL
18570 };
18571
18572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
18573 if (obj0) {
18574 {
18575 arg1 = wxString_in_helper(obj0);
18576 if (arg1 == NULL) SWIG_fail;
18577 temp1 = true;
18578 }
18579 }
18580 {
18581 if (!wxPyCheckForApp()) SWIG_fail;
18582 PyThreadState* __tstate = wxPyBeginAllowThreads();
18583 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
18584
18585 wxPyEndAllowThreads(__tstate);
18586 if (PyErr_Occurred()) SWIG_fail;
18587 }
18588 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
18589 {
18590 if (temp1)
18591 delete arg1;
18592 }
18593 return resultobj;
18594 fail:
18595 {
18596 if (temp1)
18597 delete arg1;
18598 }
18599 return NULL;
18600 }
18601
18602
18603 static PyObject *_wrap_delete_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18604 PyObject *resultobj;
18605 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18606 PyObject * obj0 = 0 ;
18607 char *kwnames[] = {
18608 (char *) "self", NULL
18609 };
18610
18611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MetaFile",kwnames,&obj0)) goto fail;
18612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18613 if (SWIG_arg_fail(1)) SWIG_fail;
18614 {
18615 PyThreadState* __tstate = wxPyBeginAllowThreads();
18616 delete arg1;
18617
18618 wxPyEndAllowThreads(__tstate);
18619 if (PyErr_Occurred()) SWIG_fail;
18620 }
18621 Py_INCREF(Py_None); resultobj = Py_None;
18622 return resultobj;
18623 fail:
18624 return NULL;
18625 }
18626
18627
18628 static PyObject *_wrap_MetaFile_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
18629 PyObject *resultobj;
18630 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18631 bool result;
18632 PyObject * obj0 = 0 ;
18633 char *kwnames[] = {
18634 (char *) "self", NULL
18635 };
18636
18637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_Ok",kwnames,&obj0)) goto fail;
18638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18639 if (SWIG_arg_fail(1)) SWIG_fail;
18640 {
18641 PyThreadState* __tstate = wxPyBeginAllowThreads();
18642 result = (bool)(arg1)->Ok();
18643
18644 wxPyEndAllowThreads(__tstate);
18645 if (PyErr_Occurred()) SWIG_fail;
18646 }
18647 {
18648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18649 }
18650 return resultobj;
18651 fail:
18652 return NULL;
18653 }
18654
18655
18656 static PyObject *_wrap_MetaFile_SetClipboard(PyObject *, PyObject *args, PyObject *kwargs) {
18657 PyObject *resultobj;
18658 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18659 int arg2 = (int) 0 ;
18660 int arg3 = (int) 0 ;
18661 bool result;
18662 PyObject * obj0 = 0 ;
18663 PyObject * obj1 = 0 ;
18664 PyObject * obj2 = 0 ;
18665 char *kwnames[] = {
18666 (char *) "self",(char *) "width",(char *) "height", NULL
18667 };
18668
18669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MetaFile_SetClipboard",kwnames,&obj0,&obj1,&obj2)) goto fail;
18670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18671 if (SWIG_arg_fail(1)) SWIG_fail;
18672 if (obj1) {
18673 {
18674 arg2 = (int)(SWIG_As_int(obj1));
18675 if (SWIG_arg_fail(2)) SWIG_fail;
18676 }
18677 }
18678 if (obj2) {
18679 {
18680 arg3 = (int)(SWIG_As_int(obj2));
18681 if (SWIG_arg_fail(3)) SWIG_fail;
18682 }
18683 }
18684 {
18685 PyThreadState* __tstate = wxPyBeginAllowThreads();
18686 result = (bool)(arg1)->SetClipboard(arg2,arg3);
18687
18688 wxPyEndAllowThreads(__tstate);
18689 if (PyErr_Occurred()) SWIG_fail;
18690 }
18691 {
18692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18693 }
18694 return resultobj;
18695 fail:
18696 return NULL;
18697 }
18698
18699
18700 static PyObject *_wrap_MetaFile_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18701 PyObject *resultobj;
18702 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18703 wxSize result;
18704 PyObject * obj0 = 0 ;
18705 char *kwnames[] = {
18706 (char *) "self", NULL
18707 };
18708
18709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetSize",kwnames,&obj0)) goto fail;
18710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18711 if (SWIG_arg_fail(1)) SWIG_fail;
18712 {
18713 PyThreadState* __tstate = wxPyBeginAllowThreads();
18714 result = (arg1)->GetSize();
18715
18716 wxPyEndAllowThreads(__tstate);
18717 if (PyErr_Occurred()) SWIG_fail;
18718 }
18719 {
18720 wxSize * resultptr;
18721 resultptr = new wxSize((wxSize &)(result));
18722 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18723 }
18724 return resultobj;
18725 fail:
18726 return NULL;
18727 }
18728
18729
18730 static PyObject *_wrap_MetaFile_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
18731 PyObject *resultobj;
18732 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18733 int result;
18734 PyObject * obj0 = 0 ;
18735 char *kwnames[] = {
18736 (char *) "self", NULL
18737 };
18738
18739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetWidth",kwnames,&obj0)) goto fail;
18740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18741 if (SWIG_arg_fail(1)) SWIG_fail;
18742 {
18743 PyThreadState* __tstate = wxPyBeginAllowThreads();
18744 result = (int)(arg1)->GetWidth();
18745
18746 wxPyEndAllowThreads(__tstate);
18747 if (PyErr_Occurred()) SWIG_fail;
18748 }
18749 {
18750 resultobj = SWIG_From_int((int)(result));
18751 }
18752 return resultobj;
18753 fail:
18754 return NULL;
18755 }
18756
18757
18758 static PyObject *_wrap_MetaFile_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
18759 PyObject *resultobj;
18760 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18761 int result;
18762 PyObject * obj0 = 0 ;
18763 char *kwnames[] = {
18764 (char *) "self", NULL
18765 };
18766
18767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetHeight",kwnames,&obj0)) goto fail;
18768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18769 if (SWIG_arg_fail(1)) SWIG_fail;
18770 {
18771 PyThreadState* __tstate = wxPyBeginAllowThreads();
18772 result = (int)(arg1)->GetHeight();
18773
18774 wxPyEndAllowThreads(__tstate);
18775 if (PyErr_Occurred()) SWIG_fail;
18776 }
18777 {
18778 resultobj = SWIG_From_int((int)(result));
18779 }
18780 return resultobj;
18781 fail:
18782 return NULL;
18783 }
18784
18785
18786 static PyObject *_wrap_MetaFile_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
18787 PyObject *resultobj;
18788 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18789 wxString *result;
18790 PyObject * obj0 = 0 ;
18791 char *kwnames[] = {
18792 (char *) "self", NULL
18793 };
18794
18795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetFileName",kwnames,&obj0)) goto fail;
18796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18797 if (SWIG_arg_fail(1)) SWIG_fail;
18798 {
18799 PyThreadState* __tstate = wxPyBeginAllowThreads();
18800 {
18801 wxString const &_result_ref = ((wxMetaFile const *)arg1)->GetFileName();
18802 result = (wxString *) &_result_ref;
18803 }
18804
18805 wxPyEndAllowThreads(__tstate);
18806 if (PyErr_Occurred()) SWIG_fail;
18807 }
18808 {
18809 #if wxUSE_UNICODE
18810 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18811 #else
18812 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18813 #endif
18814 }
18815 return resultobj;
18816 fail:
18817 return NULL;
18818 }
18819
18820
18821 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
18822 PyObject *obj;
18823 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18824 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
18825 Py_INCREF(obj);
18826 return Py_BuildValue((char *)"");
18827 }
18828 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
18829 PyObject *resultobj;
18830 wxString const &arg1_defvalue = wxPyEmptyString ;
18831 wxString *arg1 = (wxString *) &arg1_defvalue ;
18832 int arg2 = (int) 0 ;
18833 int arg3 = (int) 0 ;
18834 wxString const &arg4_defvalue = wxPyEmptyString ;
18835 wxString *arg4 = (wxString *) &arg4_defvalue ;
18836 wxMetaFileDC *result;
18837 bool temp1 = false ;
18838 bool temp4 = false ;
18839 PyObject * obj0 = 0 ;
18840 PyObject * obj1 = 0 ;
18841 PyObject * obj2 = 0 ;
18842 PyObject * obj3 = 0 ;
18843 char *kwnames[] = {
18844 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
18845 };
18846
18847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18848 if (obj0) {
18849 {
18850 arg1 = wxString_in_helper(obj0);
18851 if (arg1 == NULL) SWIG_fail;
18852 temp1 = true;
18853 }
18854 }
18855 if (obj1) {
18856 {
18857 arg2 = (int)(SWIG_As_int(obj1));
18858 if (SWIG_arg_fail(2)) SWIG_fail;
18859 }
18860 }
18861 if (obj2) {
18862 {
18863 arg3 = (int)(SWIG_As_int(obj2));
18864 if (SWIG_arg_fail(3)) SWIG_fail;
18865 }
18866 }
18867 if (obj3) {
18868 {
18869 arg4 = wxString_in_helper(obj3);
18870 if (arg4 == NULL) SWIG_fail;
18871 temp4 = true;
18872 }
18873 }
18874 {
18875 if (!wxPyCheckForApp()) SWIG_fail;
18876 PyThreadState* __tstate = wxPyBeginAllowThreads();
18877 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
18878
18879 wxPyEndAllowThreads(__tstate);
18880 if (PyErr_Occurred()) SWIG_fail;
18881 }
18882 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
18883 {
18884 if (temp1)
18885 delete arg1;
18886 }
18887 {
18888 if (temp4)
18889 delete arg4;
18890 }
18891 return resultobj;
18892 fail:
18893 {
18894 if (temp1)
18895 delete arg1;
18896 }
18897 {
18898 if (temp4)
18899 delete arg4;
18900 }
18901 return NULL;
18902 }
18903
18904
18905 static PyObject *_wrap_MetaFileDC_Close(PyObject *, PyObject *args, PyObject *kwargs) {
18906 PyObject *resultobj;
18907 wxMetaFileDC *arg1 = (wxMetaFileDC *) 0 ;
18908 wxMetaFile *result;
18909 PyObject * obj0 = 0 ;
18910 char *kwnames[] = {
18911 (char *) "self", NULL
18912 };
18913
18914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFileDC_Close",kwnames,&obj0)) goto fail;
18915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFileDC, SWIG_POINTER_EXCEPTION | 0);
18916 if (SWIG_arg_fail(1)) SWIG_fail;
18917 {
18918 PyThreadState* __tstate = wxPyBeginAllowThreads();
18919 result = (wxMetaFile *)(arg1)->Close();
18920
18921 wxPyEndAllowThreads(__tstate);
18922 if (PyErr_Occurred()) SWIG_fail;
18923 }
18924 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 0);
18925 return resultobj;
18926 fail:
18927 return NULL;
18928 }
18929
18930
18931 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
18932 PyObject *obj;
18933 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18934 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
18935 Py_INCREF(obj);
18936 return Py_BuildValue((char *)"");
18937 }
18938 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
18939 PyObject *resultobj;
18940 wxPrintData *arg1 = 0 ;
18941 wxPrinterDC *result;
18942 PyObject * obj0 = 0 ;
18943 char *kwnames[] = {
18944 (char *) "printData", NULL
18945 };
18946
18947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
18948 {
18949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18950 if (SWIG_arg_fail(1)) SWIG_fail;
18951 if (arg1 == NULL) {
18952 SWIG_null_ref("wxPrintData");
18953 }
18954 if (SWIG_arg_fail(1)) SWIG_fail;
18955 }
18956 {
18957 if (!wxPyCheckForApp()) SWIG_fail;
18958 PyThreadState* __tstate = wxPyBeginAllowThreads();
18959 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
18960
18961 wxPyEndAllowThreads(__tstate);
18962 if (PyErr_Occurred()) SWIG_fail;
18963 }
18964 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
18965 return resultobj;
18966 fail:
18967 return NULL;
18968 }
18969
18970
18971 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
18972 PyObject *obj;
18973 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18974 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
18975 Py_INCREF(obj);
18976 return Py_BuildValue((char *)"");
18977 }
18978 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18979 PyObject *resultobj;
18980 int arg1 ;
18981 int arg2 ;
18982 int arg3 = (int) true ;
18983 int arg4 = (int) 1 ;
18984 wxImageList *result;
18985 PyObject * obj0 = 0 ;
18986 PyObject * obj1 = 0 ;
18987 PyObject * obj2 = 0 ;
18988 PyObject * obj3 = 0 ;
18989 char *kwnames[] = {
18990 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
18991 };
18992
18993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18994 {
18995 arg1 = (int)(SWIG_As_int(obj0));
18996 if (SWIG_arg_fail(1)) SWIG_fail;
18997 }
18998 {
18999 arg2 = (int)(SWIG_As_int(obj1));
19000 if (SWIG_arg_fail(2)) SWIG_fail;
19001 }
19002 if (obj2) {
19003 {
19004 arg3 = (int)(SWIG_As_int(obj2));
19005 if (SWIG_arg_fail(3)) SWIG_fail;
19006 }
19007 }
19008 if (obj3) {
19009 {
19010 arg4 = (int)(SWIG_As_int(obj3));
19011 if (SWIG_arg_fail(4)) SWIG_fail;
19012 }
19013 }
19014 {
19015 if (!wxPyCheckForApp()) SWIG_fail;
19016 PyThreadState* __tstate = wxPyBeginAllowThreads();
19017 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
19018
19019 wxPyEndAllowThreads(__tstate);
19020 if (PyErr_Occurred()) SWIG_fail;
19021 }
19022 {
19023 resultobj = wxPyMake_wxObject(result, 1);
19024 }
19025 return resultobj;
19026 fail:
19027 return NULL;
19028 }
19029
19030
19031 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
19032 PyObject *resultobj;
19033 wxImageList *arg1 = (wxImageList *) 0 ;
19034 PyObject * obj0 = 0 ;
19035 char *kwnames[] = {
19036 (char *) "self", NULL
19037 };
19038
19039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
19040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19041 if (SWIG_arg_fail(1)) SWIG_fail;
19042 {
19043 PyThreadState* __tstate = wxPyBeginAllowThreads();
19044 delete arg1;
19045
19046 wxPyEndAllowThreads(__tstate);
19047 if (PyErr_Occurred()) SWIG_fail;
19048 }
19049 Py_INCREF(Py_None); resultobj = Py_None;
19050 return resultobj;
19051 fail:
19052 return NULL;
19053 }
19054
19055
19056 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
19057 PyObject *resultobj;
19058 wxImageList *arg1 = (wxImageList *) 0 ;
19059 wxBitmap *arg2 = 0 ;
19060 wxBitmap const &arg3_defvalue = wxNullBitmap ;
19061 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
19062 int result;
19063 PyObject * obj0 = 0 ;
19064 PyObject * obj1 = 0 ;
19065 PyObject * obj2 = 0 ;
19066 char *kwnames[] = {
19067 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
19068 };
19069
19070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
19071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19072 if (SWIG_arg_fail(1)) SWIG_fail;
19073 {
19074 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19075 if (SWIG_arg_fail(2)) SWIG_fail;
19076 if (arg2 == NULL) {
19077 SWIG_null_ref("wxBitmap");
19078 }
19079 if (SWIG_arg_fail(2)) SWIG_fail;
19080 }
19081 if (obj2) {
19082 {
19083 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19084 if (SWIG_arg_fail(3)) SWIG_fail;
19085 if (arg3 == NULL) {
19086 SWIG_null_ref("wxBitmap");
19087 }
19088 if (SWIG_arg_fail(3)) SWIG_fail;
19089 }
19090 }
19091 {
19092 PyThreadState* __tstate = wxPyBeginAllowThreads();
19093 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
19094
19095 wxPyEndAllowThreads(__tstate);
19096 if (PyErr_Occurred()) SWIG_fail;
19097 }
19098 {
19099 resultobj = SWIG_From_int((int)(result));
19100 }
19101 return resultobj;
19102 fail:
19103 return NULL;
19104 }
19105
19106
19107 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
19108 PyObject *resultobj;
19109 wxImageList *arg1 = (wxImageList *) 0 ;
19110 wxBitmap *arg2 = 0 ;
19111 wxColour *arg3 = 0 ;
19112 int result;
19113 wxColour temp3 ;
19114 PyObject * obj0 = 0 ;
19115 PyObject * obj1 = 0 ;
19116 PyObject * obj2 = 0 ;
19117 char *kwnames[] = {
19118 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
19119 };
19120
19121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
19122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19123 if (SWIG_arg_fail(1)) SWIG_fail;
19124 {
19125 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19126 if (SWIG_arg_fail(2)) SWIG_fail;
19127 if (arg2 == NULL) {
19128 SWIG_null_ref("wxBitmap");
19129 }
19130 if (SWIG_arg_fail(2)) SWIG_fail;
19131 }
19132 {
19133 arg3 = &temp3;
19134 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19135 }
19136 {
19137 PyThreadState* __tstate = wxPyBeginAllowThreads();
19138 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
19139
19140 wxPyEndAllowThreads(__tstate);
19141 if (PyErr_Occurred()) SWIG_fail;
19142 }
19143 {
19144 resultobj = SWIG_From_int((int)(result));
19145 }
19146 return resultobj;
19147 fail:
19148 return NULL;
19149 }
19150
19151
19152 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
19153 PyObject *resultobj;
19154 wxImageList *arg1 = (wxImageList *) 0 ;
19155 wxIcon *arg2 = 0 ;
19156 int result;
19157 PyObject * obj0 = 0 ;
19158 PyObject * obj1 = 0 ;
19159 char *kwnames[] = {
19160 (char *) "self",(char *) "icon", NULL
19161 };
19162
19163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
19164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19165 if (SWIG_arg_fail(1)) SWIG_fail;
19166 {
19167 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
19168 if (SWIG_arg_fail(2)) SWIG_fail;
19169 if (arg2 == NULL) {
19170 SWIG_null_ref("wxIcon");
19171 }
19172 if (SWIG_arg_fail(2)) SWIG_fail;
19173 }
19174 {
19175 PyThreadState* __tstate = wxPyBeginAllowThreads();
19176 result = (int)(arg1)->Add((wxIcon const &)*arg2);
19177
19178 wxPyEndAllowThreads(__tstate);
19179 if (PyErr_Occurred()) SWIG_fail;
19180 }
19181 {
19182 resultobj = SWIG_From_int((int)(result));
19183 }
19184 return resultobj;
19185 fail:
19186 return NULL;
19187 }
19188
19189
19190 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
19191 PyObject *resultobj;
19192 wxImageList *arg1 = (wxImageList *) 0 ;
19193 int arg2 ;
19194 wxBitmap *arg3 = 0 ;
19195 wxBitmap const &arg4_defvalue = wxNullBitmap ;
19196 wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
19197 bool result;
19198 PyObject * obj0 = 0 ;
19199 PyObject * obj1 = 0 ;
19200 PyObject * obj2 = 0 ;
19201 PyObject * obj3 = 0 ;
19202 char *kwnames[] = {
19203 (char *) "self",(char *) "index",(char *) "bitmap",(char *) "mask", NULL
19204 };
19205
19206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ImageList_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19208 if (SWIG_arg_fail(1)) SWIG_fail;
19209 {
19210 arg2 = (int)(SWIG_As_int(obj1));
19211 if (SWIG_arg_fail(2)) SWIG_fail;
19212 }
19213 {
19214 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19215 if (SWIG_arg_fail(3)) SWIG_fail;
19216 if (arg3 == NULL) {
19217 SWIG_null_ref("wxBitmap");
19218 }
19219 if (SWIG_arg_fail(3)) SWIG_fail;
19220 }
19221 if (obj3) {
19222 {
19223 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19224 if (SWIG_arg_fail(4)) SWIG_fail;
19225 if (arg4 == NULL) {
19226 SWIG_null_ref("wxBitmap");
19227 }
19228 if (SWIG_arg_fail(4)) SWIG_fail;
19229 }
19230 }
19231 {
19232 PyThreadState* __tstate = wxPyBeginAllowThreads();
19233 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3,(wxBitmap const &)*arg4);
19234
19235 wxPyEndAllowThreads(__tstate);
19236 if (PyErr_Occurred()) SWIG_fail;
19237 }
19238 {
19239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19240 }
19241 return resultobj;
19242 fail:
19243 return NULL;
19244 }
19245
19246
19247 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
19248 PyObject *resultobj;
19249 wxImageList *arg1 = (wxImageList *) 0 ;
19250 int arg2 ;
19251 wxDC *arg3 = 0 ;
19252 int arg4 ;
19253 int arg5 ;
19254 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
19255 bool arg7 = (bool) (bool)false ;
19256 bool result;
19257 PyObject * obj0 = 0 ;
19258 PyObject * obj1 = 0 ;
19259 PyObject * obj2 = 0 ;
19260 PyObject * obj3 = 0 ;
19261 PyObject * obj4 = 0 ;
19262 PyObject * obj5 = 0 ;
19263 PyObject * obj6 = 0 ;
19264 char *kwnames[] = {
19265 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
19266 };
19267
19268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19270 if (SWIG_arg_fail(1)) SWIG_fail;
19271 {
19272 arg2 = (int)(SWIG_As_int(obj1));
19273 if (SWIG_arg_fail(2)) SWIG_fail;
19274 }
19275 {
19276 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19277 if (SWIG_arg_fail(3)) SWIG_fail;
19278 if (arg3 == NULL) {
19279 SWIG_null_ref("wxDC");
19280 }
19281 if (SWIG_arg_fail(3)) SWIG_fail;
19282 }
19283 {
19284 arg4 = (int)(SWIG_As_int(obj3));
19285 if (SWIG_arg_fail(4)) SWIG_fail;
19286 }
19287 {
19288 arg5 = (int)(SWIG_As_int(obj4));
19289 if (SWIG_arg_fail(5)) SWIG_fail;
19290 }
19291 if (obj5) {
19292 {
19293 arg6 = (int)(SWIG_As_int(obj5));
19294 if (SWIG_arg_fail(6)) SWIG_fail;
19295 }
19296 }
19297 if (obj6) {
19298 {
19299 arg7 = (bool const)(SWIG_As_bool(obj6));
19300 if (SWIG_arg_fail(7)) SWIG_fail;
19301 }
19302 }
19303 {
19304 PyThreadState* __tstate = wxPyBeginAllowThreads();
19305 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
19306
19307 wxPyEndAllowThreads(__tstate);
19308 if (PyErr_Occurred()) SWIG_fail;
19309 }
19310 {
19311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19312 }
19313 return resultobj;
19314 fail:
19315 return NULL;
19316 }
19317
19318
19319 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
19320 PyObject *resultobj;
19321 wxImageList *arg1 = (wxImageList *) 0 ;
19322 int result;
19323 PyObject * obj0 = 0 ;
19324 char *kwnames[] = {
19325 (char *) "self", NULL
19326 };
19327
19328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
19329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19330 if (SWIG_arg_fail(1)) SWIG_fail;
19331 {
19332 PyThreadState* __tstate = wxPyBeginAllowThreads();
19333 result = (int)(arg1)->GetImageCount();
19334
19335 wxPyEndAllowThreads(__tstate);
19336 if (PyErr_Occurred()) SWIG_fail;
19337 }
19338 {
19339 resultobj = SWIG_From_int((int)(result));
19340 }
19341 return resultobj;
19342 fail:
19343 return NULL;
19344 }
19345
19346
19347 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
19348 PyObject *resultobj;
19349 wxImageList *arg1 = (wxImageList *) 0 ;
19350 int arg2 ;
19351 bool result;
19352 PyObject * obj0 = 0 ;
19353 PyObject * obj1 = 0 ;
19354 char *kwnames[] = {
19355 (char *) "self",(char *) "index", NULL
19356 };
19357
19358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
19359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19360 if (SWIG_arg_fail(1)) SWIG_fail;
19361 {
19362 arg2 = (int)(SWIG_As_int(obj1));
19363 if (SWIG_arg_fail(2)) SWIG_fail;
19364 }
19365 {
19366 PyThreadState* __tstate = wxPyBeginAllowThreads();
19367 result = (bool)(arg1)->Remove(arg2);
19368
19369 wxPyEndAllowThreads(__tstate);
19370 if (PyErr_Occurred()) SWIG_fail;
19371 }
19372 {
19373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19374 }
19375 return resultobj;
19376 fail:
19377 return NULL;
19378 }
19379
19380
19381 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
19382 PyObject *resultobj;
19383 wxImageList *arg1 = (wxImageList *) 0 ;
19384 bool result;
19385 PyObject * obj0 = 0 ;
19386 char *kwnames[] = {
19387 (char *) "self", NULL
19388 };
19389
19390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
19391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19392 if (SWIG_arg_fail(1)) SWIG_fail;
19393 {
19394 PyThreadState* __tstate = wxPyBeginAllowThreads();
19395 result = (bool)(arg1)->RemoveAll();
19396
19397 wxPyEndAllowThreads(__tstate);
19398 if (PyErr_Occurred()) SWIG_fail;
19399 }
19400 {
19401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19402 }
19403 return resultobj;
19404 fail:
19405 return NULL;
19406 }
19407
19408
19409 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19410 PyObject *resultobj;
19411 wxImageList *arg1 = (wxImageList *) 0 ;
19412 int arg2 ;
19413 int *arg3 = 0 ;
19414 int *arg4 = 0 ;
19415 int temp3 ;
19416 int res3 = 0 ;
19417 int temp4 ;
19418 int res4 = 0 ;
19419 PyObject * obj0 = 0 ;
19420 PyObject * obj1 = 0 ;
19421 char *kwnames[] = {
19422 (char *) "self",(char *) "index", NULL
19423 };
19424
19425 arg3 = &temp3; res3 = SWIG_NEWOBJ;
19426 arg4 = &temp4; res4 = SWIG_NEWOBJ;
19427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
19428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19429 if (SWIG_arg_fail(1)) SWIG_fail;
19430 {
19431 arg2 = (int)(SWIG_As_int(obj1));
19432 if (SWIG_arg_fail(2)) SWIG_fail;
19433 }
19434 {
19435 PyThreadState* __tstate = wxPyBeginAllowThreads();
19436 (arg1)->GetSize(arg2,*arg3,*arg4);
19437
19438 wxPyEndAllowThreads(__tstate);
19439 if (PyErr_Occurred()) SWIG_fail;
19440 }
19441 Py_INCREF(Py_None); resultobj = Py_None;
19442 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19443 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19444 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
19445 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
19446 return resultobj;
19447 fail:
19448 return NULL;
19449 }
19450
19451
19452 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
19453 PyObject *obj;
19454 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19455 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
19456 Py_INCREF(obj);
19457 return Py_BuildValue((char *)"");
19458 }
19459 static int _wrap_NORMAL_FONT_set(PyObject *) {
19460 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
19461 return 1;
19462 }
19463
19464
19465 static PyObject *_wrap_NORMAL_FONT_get(void) {
19466 PyObject *pyobj;
19467
19468 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
19469 return pyobj;
19470 }
19471
19472
19473 static int _wrap_SMALL_FONT_set(PyObject *) {
19474 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
19475 return 1;
19476 }
19477
19478
19479 static PyObject *_wrap_SMALL_FONT_get(void) {
19480 PyObject *pyobj;
19481
19482 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
19483 return pyobj;
19484 }
19485
19486
19487 static int _wrap_ITALIC_FONT_set(PyObject *) {
19488 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
19489 return 1;
19490 }
19491
19492
19493 static PyObject *_wrap_ITALIC_FONT_get(void) {
19494 PyObject *pyobj;
19495
19496 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
19497 return pyobj;
19498 }
19499
19500
19501 static int _wrap_SWISS_FONT_set(PyObject *) {
19502 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
19503 return 1;
19504 }
19505
19506
19507 static PyObject *_wrap_SWISS_FONT_get(void) {
19508 PyObject *pyobj;
19509
19510 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
19511 return pyobj;
19512 }
19513
19514
19515 static int _wrap_RED_PEN_set(PyObject *) {
19516 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
19517 return 1;
19518 }
19519
19520
19521 static PyObject *_wrap_RED_PEN_get(void) {
19522 PyObject *pyobj;
19523
19524 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
19525 return pyobj;
19526 }
19527
19528
19529 static int _wrap_CYAN_PEN_set(PyObject *) {
19530 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
19531 return 1;
19532 }
19533
19534
19535 static PyObject *_wrap_CYAN_PEN_get(void) {
19536 PyObject *pyobj;
19537
19538 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
19539 return pyobj;
19540 }
19541
19542
19543 static int _wrap_GREEN_PEN_set(PyObject *) {
19544 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
19545 return 1;
19546 }
19547
19548
19549 static PyObject *_wrap_GREEN_PEN_get(void) {
19550 PyObject *pyobj;
19551
19552 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
19553 return pyobj;
19554 }
19555
19556
19557 static int _wrap_BLACK_PEN_set(PyObject *) {
19558 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
19559 return 1;
19560 }
19561
19562
19563 static PyObject *_wrap_BLACK_PEN_get(void) {
19564 PyObject *pyobj;
19565
19566 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
19567 return pyobj;
19568 }
19569
19570
19571 static int _wrap_WHITE_PEN_set(PyObject *) {
19572 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
19573 return 1;
19574 }
19575
19576
19577 static PyObject *_wrap_WHITE_PEN_get(void) {
19578 PyObject *pyobj;
19579
19580 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
19581 return pyobj;
19582 }
19583
19584
19585 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
19586 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
19587 return 1;
19588 }
19589
19590
19591 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
19592 PyObject *pyobj;
19593
19594 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
19595 return pyobj;
19596 }
19597
19598
19599 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
19600 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
19601 return 1;
19602 }
19603
19604
19605 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
19606 PyObject *pyobj;
19607
19608 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
19609 return pyobj;
19610 }
19611
19612
19613 static int _wrap_GREY_PEN_set(PyObject *) {
19614 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
19615 return 1;
19616 }
19617
19618
19619 static PyObject *_wrap_GREY_PEN_get(void) {
19620 PyObject *pyobj;
19621
19622 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
19623 return pyobj;
19624 }
19625
19626
19627 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
19628 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
19629 return 1;
19630 }
19631
19632
19633 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
19634 PyObject *pyobj;
19635
19636 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19637 return pyobj;
19638 }
19639
19640
19641 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
19642 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
19643 return 1;
19644 }
19645
19646
19647 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
19648 PyObject *pyobj;
19649
19650 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19651 return pyobj;
19652 }
19653
19654
19655 static int _wrap_BLUE_BRUSH_set(PyObject *) {
19656 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
19657 return 1;
19658 }
19659
19660
19661 static PyObject *_wrap_BLUE_BRUSH_get(void) {
19662 PyObject *pyobj;
19663
19664 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19665 return pyobj;
19666 }
19667
19668
19669 static int _wrap_GREEN_BRUSH_set(PyObject *) {
19670 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
19671 return 1;
19672 }
19673
19674
19675 static PyObject *_wrap_GREEN_BRUSH_get(void) {
19676 PyObject *pyobj;
19677
19678 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19679 return pyobj;
19680 }
19681
19682
19683 static int _wrap_WHITE_BRUSH_set(PyObject *) {
19684 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
19685 return 1;
19686 }
19687
19688
19689 static PyObject *_wrap_WHITE_BRUSH_get(void) {
19690 PyObject *pyobj;
19691
19692 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19693 return pyobj;
19694 }
19695
19696
19697 static int _wrap_BLACK_BRUSH_set(PyObject *) {
19698 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
19699 return 1;
19700 }
19701
19702
19703 static PyObject *_wrap_BLACK_BRUSH_get(void) {
19704 PyObject *pyobj;
19705
19706 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
19707 return pyobj;
19708 }
19709
19710
19711 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
19712 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
19713 return 1;
19714 }
19715
19716
19717 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
19718 PyObject *pyobj;
19719
19720 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
19721 return pyobj;
19722 }
19723
19724
19725 static int _wrap_CYAN_BRUSH_set(PyObject *) {
19726 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
19727 return 1;
19728 }
19729
19730
19731 static PyObject *_wrap_CYAN_BRUSH_get(void) {
19732 PyObject *pyobj;
19733
19734 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19735 return pyobj;
19736 }
19737
19738
19739 static int _wrap_RED_BRUSH_set(PyObject *) {
19740 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
19741 return 1;
19742 }
19743
19744
19745 static PyObject *_wrap_RED_BRUSH_get(void) {
19746 PyObject *pyobj;
19747
19748 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
19749 return pyobj;
19750 }
19751
19752
19753 static int _wrap_GREY_BRUSH_set(PyObject *) {
19754 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
19755 return 1;
19756 }
19757
19758
19759 static PyObject *_wrap_GREY_BRUSH_get(void) {
19760 PyObject *pyobj;
19761
19762 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19763 return pyobj;
19764 }
19765
19766
19767 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
19768 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
19769 return 1;
19770 }
19771
19772
19773 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
19774 PyObject *pyobj;
19775
19776 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19777 return pyobj;
19778 }
19779
19780
19781 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
19782 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
19783 return 1;
19784 }
19785
19786
19787 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
19788 PyObject *pyobj;
19789
19790 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19791 return pyobj;
19792 }
19793
19794
19795 static int _wrap_BLACK_set(PyObject *) {
19796 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
19797 return 1;
19798 }
19799
19800
19801 static PyObject *_wrap_BLACK_get(void) {
19802 PyObject *pyobj;
19803
19804 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
19805 return pyobj;
19806 }
19807
19808
19809 static int _wrap_WHITE_set(PyObject *) {
19810 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
19811 return 1;
19812 }
19813
19814
19815 static PyObject *_wrap_WHITE_get(void) {
19816 PyObject *pyobj;
19817
19818 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
19819 return pyobj;
19820 }
19821
19822
19823 static int _wrap_RED_set(PyObject *) {
19824 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
19825 return 1;
19826 }
19827
19828
19829 static PyObject *_wrap_RED_get(void) {
19830 PyObject *pyobj;
19831
19832 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
19833 return pyobj;
19834 }
19835
19836
19837 static int _wrap_BLUE_set(PyObject *) {
19838 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
19839 return 1;
19840 }
19841
19842
19843 static PyObject *_wrap_BLUE_get(void) {
19844 PyObject *pyobj;
19845
19846 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
19847 return pyobj;
19848 }
19849
19850
19851 static int _wrap_GREEN_set(PyObject *) {
19852 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
19853 return 1;
19854 }
19855
19856
19857 static PyObject *_wrap_GREEN_get(void) {
19858 PyObject *pyobj;
19859
19860 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
19861 return pyobj;
19862 }
19863
19864
19865 static int _wrap_CYAN_set(PyObject *) {
19866 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
19867 return 1;
19868 }
19869
19870
19871 static PyObject *_wrap_CYAN_get(void) {
19872 PyObject *pyobj;
19873
19874 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
19875 return pyobj;
19876 }
19877
19878
19879 static int _wrap_LIGHT_GREY_set(PyObject *) {
19880 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
19881 return 1;
19882 }
19883
19884
19885 static PyObject *_wrap_LIGHT_GREY_get(void) {
19886 PyObject *pyobj;
19887
19888 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
19889 return pyobj;
19890 }
19891
19892
19893 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
19894 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
19895 return 1;
19896 }
19897
19898
19899 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
19900 PyObject *pyobj;
19901
19902 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
19903 return pyobj;
19904 }
19905
19906
19907 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
19908 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
19909 return 1;
19910 }
19911
19912
19913 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
19914 PyObject *pyobj;
19915
19916 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19917 return pyobj;
19918 }
19919
19920
19921 static int _wrap_CROSS_CURSOR_set(PyObject *) {
19922 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
19923 return 1;
19924 }
19925
19926
19927 static PyObject *_wrap_CROSS_CURSOR_get(void) {
19928 PyObject *pyobj;
19929
19930 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19931 return pyobj;
19932 }
19933
19934
19935 static int _wrap_NullBitmap_set(PyObject *) {
19936 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
19937 return 1;
19938 }
19939
19940
19941 static PyObject *_wrap_NullBitmap_get(void) {
19942 PyObject *pyobj;
19943
19944 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
19945 return pyobj;
19946 }
19947
19948
19949 static int _wrap_NullIcon_set(PyObject *) {
19950 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
19951 return 1;
19952 }
19953
19954
19955 static PyObject *_wrap_NullIcon_get(void) {
19956 PyObject *pyobj;
19957
19958 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
19959 return pyobj;
19960 }
19961
19962
19963 static int _wrap_NullCursor_set(PyObject *) {
19964 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
19965 return 1;
19966 }
19967
19968
19969 static PyObject *_wrap_NullCursor_get(void) {
19970 PyObject *pyobj;
19971
19972 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
19973 return pyobj;
19974 }
19975
19976
19977 static int _wrap_NullPen_set(PyObject *) {
19978 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
19979 return 1;
19980 }
19981
19982
19983 static PyObject *_wrap_NullPen_get(void) {
19984 PyObject *pyobj;
19985
19986 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
19987 return pyobj;
19988 }
19989
19990
19991 static int _wrap_NullBrush_set(PyObject *) {
19992 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
19993 return 1;
19994 }
19995
19996
19997 static PyObject *_wrap_NullBrush_get(void) {
19998 PyObject *pyobj;
19999
20000 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
20001 return pyobj;
20002 }
20003
20004
20005 static int _wrap_NullPalette_set(PyObject *) {
20006 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
20007 return 1;
20008 }
20009
20010
20011 static PyObject *_wrap_NullPalette_get(void) {
20012 PyObject *pyobj;
20013
20014 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
20015 return pyobj;
20016 }
20017
20018
20019 static int _wrap_NullFont_set(PyObject *) {
20020 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
20021 return 1;
20022 }
20023
20024
20025 static PyObject *_wrap_NullFont_get(void) {
20026 PyObject *pyobj;
20027
20028 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
20029 return pyobj;
20030 }
20031
20032
20033 static int _wrap_NullColour_set(PyObject *) {
20034 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
20035 return 1;
20036 }
20037
20038
20039 static PyObject *_wrap_NullColour_get(void) {
20040 PyObject *pyobj;
20041
20042 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
20043 return pyobj;
20044 }
20045
20046
20047 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
20048 PyObject *resultobj;
20049 wxPenList *arg1 = (wxPenList *) 0 ;
20050 wxPen *arg2 = (wxPen *) 0 ;
20051 PyObject * obj0 = 0 ;
20052 PyObject * obj1 = 0 ;
20053 char *kwnames[] = {
20054 (char *) "self",(char *) "pen", NULL
20055 };
20056
20057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
20058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20059 if (SWIG_arg_fail(1)) SWIG_fail;
20060 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
20061 if (SWIG_arg_fail(2)) SWIG_fail;
20062 {
20063 PyThreadState* __tstate = wxPyBeginAllowThreads();
20064 (arg1)->AddPen(arg2);
20065
20066 wxPyEndAllowThreads(__tstate);
20067 if (PyErr_Occurred()) SWIG_fail;
20068 }
20069 Py_INCREF(Py_None); resultobj = Py_None;
20070 return resultobj;
20071 fail:
20072 return NULL;
20073 }
20074
20075
20076 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
20077 PyObject *resultobj;
20078 wxPenList *arg1 = (wxPenList *) 0 ;
20079 wxColour *arg2 = 0 ;
20080 int arg3 ;
20081 int arg4 ;
20082 wxPen *result;
20083 wxColour temp2 ;
20084 PyObject * obj0 = 0 ;
20085 PyObject * obj1 = 0 ;
20086 PyObject * obj2 = 0 ;
20087 PyObject * obj3 = 0 ;
20088 char *kwnames[] = {
20089 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
20090 };
20091
20092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20094 if (SWIG_arg_fail(1)) SWIG_fail;
20095 {
20096 arg2 = &temp2;
20097 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20098 }
20099 {
20100 arg3 = (int)(SWIG_As_int(obj2));
20101 if (SWIG_arg_fail(3)) SWIG_fail;
20102 }
20103 {
20104 arg4 = (int)(SWIG_As_int(obj3));
20105 if (SWIG_arg_fail(4)) SWIG_fail;
20106 }
20107 {
20108 PyThreadState* __tstate = wxPyBeginAllowThreads();
20109 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
20110
20111 wxPyEndAllowThreads(__tstate);
20112 if (PyErr_Occurred()) SWIG_fail;
20113 }
20114 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
20115 return resultobj;
20116 fail:
20117 return NULL;
20118 }
20119
20120
20121 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
20122 PyObject *resultobj;
20123 wxPenList *arg1 = (wxPenList *) 0 ;
20124 wxPen *arg2 = (wxPen *) 0 ;
20125 PyObject * obj0 = 0 ;
20126 PyObject * obj1 = 0 ;
20127 char *kwnames[] = {
20128 (char *) "self",(char *) "pen", NULL
20129 };
20130
20131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
20132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20133 if (SWIG_arg_fail(1)) SWIG_fail;
20134 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
20135 if (SWIG_arg_fail(2)) SWIG_fail;
20136 {
20137 PyThreadState* __tstate = wxPyBeginAllowThreads();
20138 (arg1)->RemovePen(arg2);
20139
20140 wxPyEndAllowThreads(__tstate);
20141 if (PyErr_Occurred()) SWIG_fail;
20142 }
20143 Py_INCREF(Py_None); resultobj = Py_None;
20144 return resultobj;
20145 fail:
20146 return NULL;
20147 }
20148
20149
20150 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20151 PyObject *resultobj;
20152 wxPenList *arg1 = (wxPenList *) 0 ;
20153 int result;
20154 PyObject * obj0 = 0 ;
20155 char *kwnames[] = {
20156 (char *) "self", NULL
20157 };
20158
20159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
20160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20161 if (SWIG_arg_fail(1)) SWIG_fail;
20162 {
20163 PyThreadState* __tstate = wxPyBeginAllowThreads();
20164 result = (int)(arg1)->GetCount();
20165
20166 wxPyEndAllowThreads(__tstate);
20167 if (PyErr_Occurred()) SWIG_fail;
20168 }
20169 {
20170 resultobj = SWIG_From_int((int)(result));
20171 }
20172 return resultobj;
20173 fail:
20174 return NULL;
20175 }
20176
20177
20178 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
20179 PyObject *obj;
20180 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20181 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
20182 Py_INCREF(obj);
20183 return Py_BuildValue((char *)"");
20184 }
20185 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20186 PyObject *resultobj;
20187 wxBrushList *arg1 = (wxBrushList *) 0 ;
20188 wxBrush *arg2 = (wxBrush *) 0 ;
20189 PyObject * obj0 = 0 ;
20190 PyObject * obj1 = 0 ;
20191 char *kwnames[] = {
20192 (char *) "self",(char *) "brush", NULL
20193 };
20194
20195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
20196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20197 if (SWIG_arg_fail(1)) SWIG_fail;
20198 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
20199 if (SWIG_arg_fail(2)) SWIG_fail;
20200 {
20201 PyThreadState* __tstate = wxPyBeginAllowThreads();
20202 (arg1)->AddBrush(arg2);
20203
20204 wxPyEndAllowThreads(__tstate);
20205 if (PyErr_Occurred()) SWIG_fail;
20206 }
20207 Py_INCREF(Py_None); resultobj = Py_None;
20208 return resultobj;
20209 fail:
20210 return NULL;
20211 }
20212
20213
20214 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20215 PyObject *resultobj;
20216 wxBrushList *arg1 = (wxBrushList *) 0 ;
20217 wxColour *arg2 = 0 ;
20218 int arg3 ;
20219 wxBrush *result;
20220 wxColour temp2 ;
20221 PyObject * obj0 = 0 ;
20222 PyObject * obj1 = 0 ;
20223 PyObject * obj2 = 0 ;
20224 char *kwnames[] = {
20225 (char *) "self",(char *) "colour",(char *) "style", NULL
20226 };
20227
20228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
20229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20230 if (SWIG_arg_fail(1)) SWIG_fail;
20231 {
20232 arg2 = &temp2;
20233 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20234 }
20235 {
20236 arg3 = (int)(SWIG_As_int(obj2));
20237 if (SWIG_arg_fail(3)) SWIG_fail;
20238 }
20239 {
20240 PyThreadState* __tstate = wxPyBeginAllowThreads();
20241 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
20242
20243 wxPyEndAllowThreads(__tstate);
20244 if (PyErr_Occurred()) SWIG_fail;
20245 }
20246 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
20247 return resultobj;
20248 fail:
20249 return NULL;
20250 }
20251
20252
20253 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20254 PyObject *resultobj;
20255 wxBrushList *arg1 = (wxBrushList *) 0 ;
20256 wxBrush *arg2 = (wxBrush *) 0 ;
20257 PyObject * obj0 = 0 ;
20258 PyObject * obj1 = 0 ;
20259 char *kwnames[] = {
20260 (char *) "self",(char *) "brush", NULL
20261 };
20262
20263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
20264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20265 if (SWIG_arg_fail(1)) SWIG_fail;
20266 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
20267 if (SWIG_arg_fail(2)) SWIG_fail;
20268 {
20269 PyThreadState* __tstate = wxPyBeginAllowThreads();
20270 (arg1)->RemoveBrush(arg2);
20271
20272 wxPyEndAllowThreads(__tstate);
20273 if (PyErr_Occurred()) SWIG_fail;
20274 }
20275 Py_INCREF(Py_None); resultobj = Py_None;
20276 return resultobj;
20277 fail:
20278 return NULL;
20279 }
20280
20281
20282 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20283 PyObject *resultobj;
20284 wxBrushList *arg1 = (wxBrushList *) 0 ;
20285 int result;
20286 PyObject * obj0 = 0 ;
20287 char *kwnames[] = {
20288 (char *) "self", NULL
20289 };
20290
20291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
20292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20293 if (SWIG_arg_fail(1)) SWIG_fail;
20294 {
20295 PyThreadState* __tstate = wxPyBeginAllowThreads();
20296 result = (int)(arg1)->GetCount();
20297
20298 wxPyEndAllowThreads(__tstate);
20299 if (PyErr_Occurred()) SWIG_fail;
20300 }
20301 {
20302 resultobj = SWIG_From_int((int)(result));
20303 }
20304 return resultobj;
20305 fail:
20306 return NULL;
20307 }
20308
20309
20310 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
20311 PyObject *obj;
20312 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20313 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
20314 Py_INCREF(obj);
20315 return Py_BuildValue((char *)"");
20316 }
20317 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
20318 PyObject *resultobj;
20319 wxColourDatabase *result;
20320 char *kwnames[] = {
20321 NULL
20322 };
20323
20324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
20325 {
20326 if (!wxPyCheckForApp()) SWIG_fail;
20327 PyThreadState* __tstate = wxPyBeginAllowThreads();
20328 result = (wxColourDatabase *)new wxColourDatabase();
20329
20330 wxPyEndAllowThreads(__tstate);
20331 if (PyErr_Occurred()) SWIG_fail;
20332 }
20333 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
20334 return resultobj;
20335 fail:
20336 return NULL;
20337 }
20338
20339
20340 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
20341 PyObject *resultobj;
20342 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20343 PyObject * obj0 = 0 ;
20344 char *kwnames[] = {
20345 (char *) "self", NULL
20346 };
20347
20348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
20349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20350 if (SWIG_arg_fail(1)) SWIG_fail;
20351 {
20352 PyThreadState* __tstate = wxPyBeginAllowThreads();
20353 delete arg1;
20354
20355 wxPyEndAllowThreads(__tstate);
20356 if (PyErr_Occurred()) SWIG_fail;
20357 }
20358 Py_INCREF(Py_None); resultobj = Py_None;
20359 return resultobj;
20360 fail:
20361 return NULL;
20362 }
20363
20364
20365 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
20366 PyObject *resultobj;
20367 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20368 wxString *arg2 = 0 ;
20369 wxColour result;
20370 bool temp2 = false ;
20371 PyObject * obj0 = 0 ;
20372 PyObject * obj1 = 0 ;
20373 char *kwnames[] = {
20374 (char *) "self",(char *) "name", NULL
20375 };
20376
20377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
20378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20379 if (SWIG_arg_fail(1)) SWIG_fail;
20380 {
20381 arg2 = wxString_in_helper(obj1);
20382 if (arg2 == NULL) SWIG_fail;
20383 temp2 = true;
20384 }
20385 {
20386 PyThreadState* __tstate = wxPyBeginAllowThreads();
20387 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
20388
20389 wxPyEndAllowThreads(__tstate);
20390 if (PyErr_Occurred()) SWIG_fail;
20391 }
20392 {
20393 wxColour * resultptr;
20394 resultptr = new wxColour((wxColour &)(result));
20395 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20396 }
20397 {
20398 if (temp2)
20399 delete arg2;
20400 }
20401 return resultobj;
20402 fail:
20403 {
20404 if (temp2)
20405 delete arg2;
20406 }
20407 return NULL;
20408 }
20409
20410
20411 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
20412 PyObject *resultobj;
20413 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20414 wxColour *arg2 = 0 ;
20415 wxString result;
20416 wxColour temp2 ;
20417 PyObject * obj0 = 0 ;
20418 PyObject * obj1 = 0 ;
20419 char *kwnames[] = {
20420 (char *) "self",(char *) "colour", NULL
20421 };
20422
20423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
20424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20425 if (SWIG_arg_fail(1)) SWIG_fail;
20426 {
20427 arg2 = &temp2;
20428 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20429 }
20430 {
20431 PyThreadState* __tstate = wxPyBeginAllowThreads();
20432 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
20433
20434 wxPyEndAllowThreads(__tstate);
20435 if (PyErr_Occurred()) SWIG_fail;
20436 }
20437 {
20438 #if wxUSE_UNICODE
20439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20440 #else
20441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20442 #endif
20443 }
20444 return resultobj;
20445 fail:
20446 return NULL;
20447 }
20448
20449
20450 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
20451 PyObject *resultobj;
20452 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20453 wxString *arg2 = 0 ;
20454 wxColour *arg3 = 0 ;
20455 bool temp2 = false ;
20456 wxColour temp3 ;
20457 PyObject * obj0 = 0 ;
20458 PyObject * obj1 = 0 ;
20459 PyObject * obj2 = 0 ;
20460 char *kwnames[] = {
20461 (char *) "self",(char *) "name",(char *) "colour", NULL
20462 };
20463
20464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
20465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20466 if (SWIG_arg_fail(1)) SWIG_fail;
20467 {
20468 arg2 = wxString_in_helper(obj1);
20469 if (arg2 == NULL) SWIG_fail;
20470 temp2 = true;
20471 }
20472 {
20473 arg3 = &temp3;
20474 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20475 }
20476 {
20477 PyThreadState* __tstate = wxPyBeginAllowThreads();
20478 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
20479
20480 wxPyEndAllowThreads(__tstate);
20481 if (PyErr_Occurred()) SWIG_fail;
20482 }
20483 Py_INCREF(Py_None); resultobj = Py_None;
20484 {
20485 if (temp2)
20486 delete arg2;
20487 }
20488 return resultobj;
20489 fail:
20490 {
20491 if (temp2)
20492 delete arg2;
20493 }
20494 return NULL;
20495 }
20496
20497
20498 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
20499 PyObject *resultobj;
20500 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20501 wxString *arg2 = 0 ;
20502 int arg3 ;
20503 int arg4 ;
20504 int arg5 ;
20505 bool temp2 = false ;
20506 PyObject * obj0 = 0 ;
20507 PyObject * obj1 = 0 ;
20508 PyObject * obj2 = 0 ;
20509 PyObject * obj3 = 0 ;
20510 PyObject * obj4 = 0 ;
20511 char *kwnames[] = {
20512 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
20513 };
20514
20515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20517 if (SWIG_arg_fail(1)) SWIG_fail;
20518 {
20519 arg2 = wxString_in_helper(obj1);
20520 if (arg2 == NULL) SWIG_fail;
20521 temp2 = true;
20522 }
20523 {
20524 arg3 = (int)(SWIG_As_int(obj2));
20525 if (SWIG_arg_fail(3)) SWIG_fail;
20526 }
20527 {
20528 arg4 = (int)(SWIG_As_int(obj3));
20529 if (SWIG_arg_fail(4)) SWIG_fail;
20530 }
20531 {
20532 arg5 = (int)(SWIG_As_int(obj4));
20533 if (SWIG_arg_fail(5)) SWIG_fail;
20534 }
20535 {
20536 PyThreadState* __tstate = wxPyBeginAllowThreads();
20537 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
20538
20539 wxPyEndAllowThreads(__tstate);
20540 if (PyErr_Occurred()) SWIG_fail;
20541 }
20542 Py_INCREF(Py_None); resultobj = Py_None;
20543 {
20544 if (temp2)
20545 delete arg2;
20546 }
20547 return resultobj;
20548 fail:
20549 {
20550 if (temp2)
20551 delete arg2;
20552 }
20553 return NULL;
20554 }
20555
20556
20557 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
20558 PyObject *obj;
20559 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20560 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
20561 Py_INCREF(obj);
20562 return Py_BuildValue((char *)"");
20563 }
20564 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
20565 PyObject *resultobj;
20566 wxFontList *arg1 = (wxFontList *) 0 ;
20567 wxFont *arg2 = (wxFont *) 0 ;
20568 PyObject * obj0 = 0 ;
20569 PyObject * obj1 = 0 ;
20570 char *kwnames[] = {
20571 (char *) "self",(char *) "font", NULL
20572 };
20573
20574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
20575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20576 if (SWIG_arg_fail(1)) SWIG_fail;
20577 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20578 if (SWIG_arg_fail(2)) SWIG_fail;
20579 {
20580 PyThreadState* __tstate = wxPyBeginAllowThreads();
20581 (arg1)->AddFont(arg2);
20582
20583 wxPyEndAllowThreads(__tstate);
20584 if (PyErr_Occurred()) SWIG_fail;
20585 }
20586 Py_INCREF(Py_None); resultobj = Py_None;
20587 return resultobj;
20588 fail:
20589 return NULL;
20590 }
20591
20592
20593 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
20594 PyObject *resultobj;
20595 wxFontList *arg1 = (wxFontList *) 0 ;
20596 int arg2 ;
20597 int arg3 ;
20598 int arg4 ;
20599 int arg5 ;
20600 bool arg6 = (bool) false ;
20601 wxString const &arg7_defvalue = wxPyEmptyString ;
20602 wxString *arg7 = (wxString *) &arg7_defvalue ;
20603 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
20604 wxFont *result;
20605 bool temp7 = false ;
20606 PyObject * obj0 = 0 ;
20607 PyObject * obj1 = 0 ;
20608 PyObject * obj2 = 0 ;
20609 PyObject * obj3 = 0 ;
20610 PyObject * obj4 = 0 ;
20611 PyObject * obj5 = 0 ;
20612 PyObject * obj6 = 0 ;
20613 PyObject * obj7 = 0 ;
20614 char *kwnames[] = {
20615 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
20616 };
20617
20618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20620 if (SWIG_arg_fail(1)) SWIG_fail;
20621 {
20622 arg2 = (int)(SWIG_As_int(obj1));
20623 if (SWIG_arg_fail(2)) SWIG_fail;
20624 }
20625 {
20626 arg3 = (int)(SWIG_As_int(obj2));
20627 if (SWIG_arg_fail(3)) SWIG_fail;
20628 }
20629 {
20630 arg4 = (int)(SWIG_As_int(obj3));
20631 if (SWIG_arg_fail(4)) SWIG_fail;
20632 }
20633 {
20634 arg5 = (int)(SWIG_As_int(obj4));
20635 if (SWIG_arg_fail(5)) SWIG_fail;
20636 }
20637 if (obj5) {
20638 {
20639 arg6 = (bool)(SWIG_As_bool(obj5));
20640 if (SWIG_arg_fail(6)) SWIG_fail;
20641 }
20642 }
20643 if (obj6) {
20644 {
20645 arg7 = wxString_in_helper(obj6);
20646 if (arg7 == NULL) SWIG_fail;
20647 temp7 = true;
20648 }
20649 }
20650 if (obj7) {
20651 {
20652 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
20653 if (SWIG_arg_fail(8)) SWIG_fail;
20654 }
20655 }
20656 {
20657 PyThreadState* __tstate = wxPyBeginAllowThreads();
20658 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
20659
20660 wxPyEndAllowThreads(__tstate);
20661 if (PyErr_Occurred()) SWIG_fail;
20662 }
20663 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
20664 {
20665 if (temp7)
20666 delete arg7;
20667 }
20668 return resultobj;
20669 fail:
20670 {
20671 if (temp7)
20672 delete arg7;
20673 }
20674 return NULL;
20675 }
20676
20677
20678 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
20679 PyObject *resultobj;
20680 wxFontList *arg1 = (wxFontList *) 0 ;
20681 wxFont *arg2 = (wxFont *) 0 ;
20682 PyObject * obj0 = 0 ;
20683 PyObject * obj1 = 0 ;
20684 char *kwnames[] = {
20685 (char *) "self",(char *) "font", NULL
20686 };
20687
20688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
20689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20690 if (SWIG_arg_fail(1)) SWIG_fail;
20691 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20692 if (SWIG_arg_fail(2)) SWIG_fail;
20693 {
20694 PyThreadState* __tstate = wxPyBeginAllowThreads();
20695 (arg1)->RemoveFont(arg2);
20696
20697 wxPyEndAllowThreads(__tstate);
20698 if (PyErr_Occurred()) SWIG_fail;
20699 }
20700 Py_INCREF(Py_None); resultobj = Py_None;
20701 return resultobj;
20702 fail:
20703 return NULL;
20704 }
20705
20706
20707 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20708 PyObject *resultobj;
20709 wxFontList *arg1 = (wxFontList *) 0 ;
20710 int result;
20711 PyObject * obj0 = 0 ;
20712 char *kwnames[] = {
20713 (char *) "self", NULL
20714 };
20715
20716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
20717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20718 if (SWIG_arg_fail(1)) SWIG_fail;
20719 {
20720 PyThreadState* __tstate = wxPyBeginAllowThreads();
20721 result = (int)(arg1)->GetCount();
20722
20723 wxPyEndAllowThreads(__tstate);
20724 if (PyErr_Occurred()) SWIG_fail;
20725 }
20726 {
20727 resultobj = SWIG_From_int((int)(result));
20728 }
20729 return resultobj;
20730 fail:
20731 return NULL;
20732 }
20733
20734
20735 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
20736 PyObject *obj;
20737 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20738 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
20739 Py_INCREF(obj);
20740 return Py_BuildValue((char *)"");
20741 }
20742 static int _wrap_TheFontList_set(PyObject *) {
20743 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
20744 return 1;
20745 }
20746
20747
20748 static PyObject *_wrap_TheFontList_get(void) {
20749 PyObject *pyobj;
20750
20751 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
20752 return pyobj;
20753 }
20754
20755
20756 static int _wrap_ThePenList_set(PyObject *) {
20757 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
20758 return 1;
20759 }
20760
20761
20762 static PyObject *_wrap_ThePenList_get(void) {
20763 PyObject *pyobj;
20764
20765 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
20766 return pyobj;
20767 }
20768
20769
20770 static int _wrap_TheBrushList_set(PyObject *) {
20771 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
20772 return 1;
20773 }
20774
20775
20776 static PyObject *_wrap_TheBrushList_get(void) {
20777 PyObject *pyobj;
20778
20779 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
20780 return pyobj;
20781 }
20782
20783
20784 static int _wrap_TheColourDatabase_set(PyObject *) {
20785 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
20786 return 1;
20787 }
20788
20789
20790 static PyObject *_wrap_TheColourDatabase_get(void) {
20791 PyObject *pyobj;
20792
20793 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
20794 return pyobj;
20795 }
20796
20797
20798 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
20799 PyObject *resultobj;
20800 wxEffects *result;
20801 char *kwnames[] = {
20802 NULL
20803 };
20804
20805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
20806 {
20807 PyThreadState* __tstate = wxPyBeginAllowThreads();
20808 result = (wxEffects *)new wxEffects();
20809
20810 wxPyEndAllowThreads(__tstate);
20811 if (PyErr_Occurred()) SWIG_fail;
20812 }
20813 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
20814 return resultobj;
20815 fail:
20816 return NULL;
20817 }
20818
20819
20820 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20821 PyObject *resultobj;
20822 wxEffects *arg1 = (wxEffects *) 0 ;
20823 wxColour result;
20824 PyObject * obj0 = 0 ;
20825 char *kwnames[] = {
20826 (char *) "self", NULL
20827 };
20828
20829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
20830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20831 if (SWIG_arg_fail(1)) SWIG_fail;
20832 {
20833 PyThreadState* __tstate = wxPyBeginAllowThreads();
20834 result = ((wxEffects const *)arg1)->GetHighlightColour();
20835
20836 wxPyEndAllowThreads(__tstate);
20837 if (PyErr_Occurred()) SWIG_fail;
20838 }
20839 {
20840 wxColour * resultptr;
20841 resultptr = new wxColour((wxColour &)(result));
20842 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20843 }
20844 return resultobj;
20845 fail:
20846 return NULL;
20847 }
20848
20849
20850 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20851 PyObject *resultobj;
20852 wxEffects *arg1 = (wxEffects *) 0 ;
20853 wxColour result;
20854 PyObject * obj0 = 0 ;
20855 char *kwnames[] = {
20856 (char *) "self", NULL
20857 };
20858
20859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
20860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20861 if (SWIG_arg_fail(1)) SWIG_fail;
20862 {
20863 PyThreadState* __tstate = wxPyBeginAllowThreads();
20864 result = ((wxEffects const *)arg1)->GetLightShadow();
20865
20866 wxPyEndAllowThreads(__tstate);
20867 if (PyErr_Occurred()) SWIG_fail;
20868 }
20869 {
20870 wxColour * resultptr;
20871 resultptr = new wxColour((wxColour &)(result));
20872 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20873 }
20874 return resultobj;
20875 fail:
20876 return NULL;
20877 }
20878
20879
20880 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20881 PyObject *resultobj;
20882 wxEffects *arg1 = (wxEffects *) 0 ;
20883 wxColour result;
20884 PyObject * obj0 = 0 ;
20885 char *kwnames[] = {
20886 (char *) "self", NULL
20887 };
20888
20889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
20890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20891 if (SWIG_arg_fail(1)) SWIG_fail;
20892 {
20893 PyThreadState* __tstate = wxPyBeginAllowThreads();
20894 result = ((wxEffects const *)arg1)->GetFaceColour();
20895
20896 wxPyEndAllowThreads(__tstate);
20897 if (PyErr_Occurred()) SWIG_fail;
20898 }
20899 {
20900 wxColour * resultptr;
20901 resultptr = new wxColour((wxColour &)(result));
20902 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20903 }
20904 return resultobj;
20905 fail:
20906 return NULL;
20907 }
20908
20909
20910 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20911 PyObject *resultobj;
20912 wxEffects *arg1 = (wxEffects *) 0 ;
20913 wxColour result;
20914 PyObject * obj0 = 0 ;
20915 char *kwnames[] = {
20916 (char *) "self", NULL
20917 };
20918
20919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
20920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20921 if (SWIG_arg_fail(1)) SWIG_fail;
20922 {
20923 PyThreadState* __tstate = wxPyBeginAllowThreads();
20924 result = ((wxEffects const *)arg1)->GetMediumShadow();
20925
20926 wxPyEndAllowThreads(__tstate);
20927 if (PyErr_Occurred()) SWIG_fail;
20928 }
20929 {
20930 wxColour * resultptr;
20931 resultptr = new wxColour((wxColour &)(result));
20932 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20933 }
20934 return resultobj;
20935 fail:
20936 return NULL;
20937 }
20938
20939
20940 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20941 PyObject *resultobj;
20942 wxEffects *arg1 = (wxEffects *) 0 ;
20943 wxColour result;
20944 PyObject * obj0 = 0 ;
20945 char *kwnames[] = {
20946 (char *) "self", NULL
20947 };
20948
20949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
20950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20951 if (SWIG_arg_fail(1)) SWIG_fail;
20952 {
20953 PyThreadState* __tstate = wxPyBeginAllowThreads();
20954 result = ((wxEffects const *)arg1)->GetDarkShadow();
20955
20956 wxPyEndAllowThreads(__tstate);
20957 if (PyErr_Occurred()) SWIG_fail;
20958 }
20959 {
20960 wxColour * resultptr;
20961 resultptr = new wxColour((wxColour &)(result));
20962 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20963 }
20964 return resultobj;
20965 fail:
20966 return NULL;
20967 }
20968
20969
20970 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20971 PyObject *resultobj;
20972 wxEffects *arg1 = (wxEffects *) 0 ;
20973 wxColour *arg2 = 0 ;
20974 wxColour temp2 ;
20975 PyObject * obj0 = 0 ;
20976 PyObject * obj1 = 0 ;
20977 char *kwnames[] = {
20978 (char *) "self",(char *) "c", NULL
20979 };
20980
20981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
20982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20983 if (SWIG_arg_fail(1)) SWIG_fail;
20984 {
20985 arg2 = &temp2;
20986 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20987 }
20988 {
20989 PyThreadState* __tstate = wxPyBeginAllowThreads();
20990 (arg1)->SetHighlightColour((wxColour const &)*arg2);
20991
20992 wxPyEndAllowThreads(__tstate);
20993 if (PyErr_Occurred()) SWIG_fail;
20994 }
20995 Py_INCREF(Py_None); resultobj = Py_None;
20996 return resultobj;
20997 fail:
20998 return NULL;
20999 }
21000
21001
21002 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21003 PyObject *resultobj;
21004 wxEffects *arg1 = (wxEffects *) 0 ;
21005 wxColour *arg2 = 0 ;
21006 wxColour temp2 ;
21007 PyObject * obj0 = 0 ;
21008 PyObject * obj1 = 0 ;
21009 char *kwnames[] = {
21010 (char *) "self",(char *) "c", NULL
21011 };
21012
21013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
21014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21015 if (SWIG_arg_fail(1)) SWIG_fail;
21016 {
21017 arg2 = &temp2;
21018 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21019 }
21020 {
21021 PyThreadState* __tstate = wxPyBeginAllowThreads();
21022 (arg1)->SetLightShadow((wxColour const &)*arg2);
21023
21024 wxPyEndAllowThreads(__tstate);
21025 if (PyErr_Occurred()) SWIG_fail;
21026 }
21027 Py_INCREF(Py_None); resultobj = Py_None;
21028 return resultobj;
21029 fail:
21030 return NULL;
21031 }
21032
21033
21034 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
21035 PyObject *resultobj;
21036 wxEffects *arg1 = (wxEffects *) 0 ;
21037 wxColour *arg2 = 0 ;
21038 wxColour temp2 ;
21039 PyObject * obj0 = 0 ;
21040 PyObject * obj1 = 0 ;
21041 char *kwnames[] = {
21042 (char *) "self",(char *) "c", NULL
21043 };
21044
21045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
21046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21047 if (SWIG_arg_fail(1)) SWIG_fail;
21048 {
21049 arg2 = &temp2;
21050 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21051 }
21052 {
21053 PyThreadState* __tstate = wxPyBeginAllowThreads();
21054 (arg1)->SetFaceColour((wxColour const &)*arg2);
21055
21056 wxPyEndAllowThreads(__tstate);
21057 if (PyErr_Occurred()) SWIG_fail;
21058 }
21059 Py_INCREF(Py_None); resultobj = Py_None;
21060 return resultobj;
21061 fail:
21062 return NULL;
21063 }
21064
21065
21066 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21067 PyObject *resultobj;
21068 wxEffects *arg1 = (wxEffects *) 0 ;
21069 wxColour *arg2 = 0 ;
21070 wxColour temp2 ;
21071 PyObject * obj0 = 0 ;
21072 PyObject * obj1 = 0 ;
21073 char *kwnames[] = {
21074 (char *) "self",(char *) "c", NULL
21075 };
21076
21077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
21078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21079 if (SWIG_arg_fail(1)) SWIG_fail;
21080 {
21081 arg2 = &temp2;
21082 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21083 }
21084 {
21085 PyThreadState* __tstate = wxPyBeginAllowThreads();
21086 (arg1)->SetMediumShadow((wxColour const &)*arg2);
21087
21088 wxPyEndAllowThreads(__tstate);
21089 if (PyErr_Occurred()) SWIG_fail;
21090 }
21091 Py_INCREF(Py_None); resultobj = Py_None;
21092 return resultobj;
21093 fail:
21094 return NULL;
21095 }
21096
21097
21098 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21099 PyObject *resultobj;
21100 wxEffects *arg1 = (wxEffects *) 0 ;
21101 wxColour *arg2 = 0 ;
21102 wxColour temp2 ;
21103 PyObject * obj0 = 0 ;
21104 PyObject * obj1 = 0 ;
21105 char *kwnames[] = {
21106 (char *) "self",(char *) "c", NULL
21107 };
21108
21109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
21110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21111 if (SWIG_arg_fail(1)) SWIG_fail;
21112 {
21113 arg2 = &temp2;
21114 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21115 }
21116 {
21117 PyThreadState* __tstate = wxPyBeginAllowThreads();
21118 (arg1)->SetDarkShadow((wxColour const &)*arg2);
21119
21120 wxPyEndAllowThreads(__tstate);
21121 if (PyErr_Occurred()) SWIG_fail;
21122 }
21123 Py_INCREF(Py_None); resultobj = Py_None;
21124 return resultobj;
21125 fail:
21126 return NULL;
21127 }
21128
21129
21130 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
21131 PyObject *resultobj;
21132 wxEffects *arg1 = (wxEffects *) 0 ;
21133 wxColour *arg2 = 0 ;
21134 wxColour *arg3 = 0 ;
21135 wxColour *arg4 = 0 ;
21136 wxColour *arg5 = 0 ;
21137 wxColour *arg6 = 0 ;
21138 wxColour temp2 ;
21139 wxColour temp3 ;
21140 wxColour temp4 ;
21141 wxColour temp5 ;
21142 wxColour temp6 ;
21143 PyObject * obj0 = 0 ;
21144 PyObject * obj1 = 0 ;
21145 PyObject * obj2 = 0 ;
21146 PyObject * obj3 = 0 ;
21147 PyObject * obj4 = 0 ;
21148 PyObject * obj5 = 0 ;
21149 char *kwnames[] = {
21150 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
21151 };
21152
21153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
21154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21155 if (SWIG_arg_fail(1)) SWIG_fail;
21156 {
21157 arg2 = &temp2;
21158 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21159 }
21160 {
21161 arg3 = &temp3;
21162 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
21163 }
21164 {
21165 arg4 = &temp4;
21166 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
21167 }
21168 {
21169 arg5 = &temp5;
21170 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
21171 }
21172 {
21173 arg6 = &temp6;
21174 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
21175 }
21176 {
21177 PyThreadState* __tstate = wxPyBeginAllowThreads();
21178 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
21179
21180 wxPyEndAllowThreads(__tstate);
21181 if (PyErr_Occurred()) SWIG_fail;
21182 }
21183 Py_INCREF(Py_None); resultobj = Py_None;
21184 return resultobj;
21185 fail:
21186 return NULL;
21187 }
21188
21189
21190 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
21191 PyObject *resultobj;
21192 wxEffects *arg1 = (wxEffects *) 0 ;
21193 wxDC *arg2 = 0 ;
21194 wxRect *arg3 = 0 ;
21195 int arg4 = (int) 1 ;
21196 wxRect temp3 ;
21197 PyObject * obj0 = 0 ;
21198 PyObject * obj1 = 0 ;
21199 PyObject * obj2 = 0 ;
21200 PyObject * obj3 = 0 ;
21201 char *kwnames[] = {
21202 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
21203 };
21204
21205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21207 if (SWIG_arg_fail(1)) SWIG_fail;
21208 {
21209 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21210 if (SWIG_arg_fail(2)) SWIG_fail;
21211 if (arg2 == NULL) {
21212 SWIG_null_ref("wxDC");
21213 }
21214 if (SWIG_arg_fail(2)) SWIG_fail;
21215 }
21216 {
21217 arg3 = &temp3;
21218 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
21219 }
21220 if (obj3) {
21221 {
21222 arg4 = (int)(SWIG_As_int(obj3));
21223 if (SWIG_arg_fail(4)) SWIG_fail;
21224 }
21225 }
21226 {
21227 PyThreadState* __tstate = wxPyBeginAllowThreads();
21228 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
21229
21230 wxPyEndAllowThreads(__tstate);
21231 if (PyErr_Occurred()) SWIG_fail;
21232 }
21233 Py_INCREF(Py_None); resultobj = Py_None;
21234 return resultobj;
21235 fail:
21236 return NULL;
21237 }
21238
21239
21240 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
21241 PyObject *resultobj;
21242 wxEffects *arg1 = (wxEffects *) 0 ;
21243 wxRect *arg2 = 0 ;
21244 wxDC *arg3 = 0 ;
21245 wxBitmap *arg4 = 0 ;
21246 bool result;
21247 wxRect temp2 ;
21248 PyObject * obj0 = 0 ;
21249 PyObject * obj1 = 0 ;
21250 PyObject * obj2 = 0 ;
21251 PyObject * obj3 = 0 ;
21252 char *kwnames[] = {
21253 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
21254 };
21255
21256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21258 if (SWIG_arg_fail(1)) SWIG_fail;
21259 {
21260 arg2 = &temp2;
21261 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
21262 }
21263 {
21264 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21265 if (SWIG_arg_fail(3)) SWIG_fail;
21266 if (arg3 == NULL) {
21267 SWIG_null_ref("wxDC");
21268 }
21269 if (SWIG_arg_fail(3)) SWIG_fail;
21270 }
21271 {
21272 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
21273 if (SWIG_arg_fail(4)) SWIG_fail;
21274 if (arg4 == NULL) {
21275 SWIG_null_ref("wxBitmap");
21276 }
21277 if (SWIG_arg_fail(4)) SWIG_fail;
21278 }
21279 {
21280 PyThreadState* __tstate = wxPyBeginAllowThreads();
21281 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
21282
21283 wxPyEndAllowThreads(__tstate);
21284 if (PyErr_Occurred()) SWIG_fail;
21285 }
21286 {
21287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21288 }
21289 return resultobj;
21290 fail:
21291 return NULL;
21292 }
21293
21294
21295 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
21296 PyObject *obj;
21297 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21298 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
21299 Py_INCREF(obj);
21300 return Py_BuildValue((char *)"");
21301 }
21302 static PyMethodDef SwigMethods[] = {
21303 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
21304 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
21305 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
21306 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
21307 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
21308 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
21309 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
21310 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
21311 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21312 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
21313 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
21314 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
21315 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
21316 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21317 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21318 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21319 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
21320 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21321 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21322 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21323 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21324 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21325 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
21326 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
21327 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
21328 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21329 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21330 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
21331 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21332 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
21333 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
21334 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
21335 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
21336 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21337 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
21338 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21339 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21340 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21341 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
21342 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21343 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
21344 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21345 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21346 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21347 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21348 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21349 { (char *)"Pen_GetDashCount", (PyCFunction) _wrap_Pen_GetDashCount, METH_VARARGS | METH_KEYWORDS, NULL},
21350 { (char *)"Pen_GetStipple", (PyCFunction) _wrap_Pen_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21351 { (char *)"Pen_SetStipple", (PyCFunction) _wrap_Pen_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21352 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21353 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21354 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
21355 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
21356 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
21357 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21358 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21359 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21360 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21361 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21362 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21363 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
21364 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21365 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
21366 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21367 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21368 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21369 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21370 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
21371 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
21372 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
21373 { (char *)"Bitmap_GetHandle", (PyCFunction) _wrap_Bitmap_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21374 { (char *)"Bitmap_SetHandle", (PyCFunction) _wrap_Bitmap_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21375 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21376 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21377 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21378 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21379 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21380 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
21381 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
21382 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
21383 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
21384 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21385 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
21386 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
21387 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21388 { (char *)"Bitmap_SetPalette", (PyCFunction) _wrap_Bitmap_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21389 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21390 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21391 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21392 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21393 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21394 { (char *)"Bitmap_CopyFromCursor", (PyCFunction) _wrap_Bitmap_CopyFromCursor, METH_VARARGS | METH_KEYWORDS, NULL},
21395 { (char *)"Bitmap_GetQuality", (PyCFunction) _wrap_Bitmap_GetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
21396 { (char *)"Bitmap_SetQuality", (PyCFunction) _wrap_Bitmap_SetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
21397 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21398 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21399 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
21400 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
21401 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
21402 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
21403 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
21404 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21405 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21406 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21407 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
21408 { (char *)"Icon_LoadFile", (PyCFunction) _wrap_Icon_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
21409 { (char *)"Icon_GetHandle", (PyCFunction) _wrap_Icon_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21410 { (char *)"Icon_SetHandle", (PyCFunction) _wrap_Icon_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21411 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21412 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21413 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21414 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21415 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21416 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21417 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21418 { (char *)"Icon_SetSize", (PyCFunction) _wrap_Icon_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21419 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21420 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
21421 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21422 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21423 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21424 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21425 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21426 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
21427 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
21428 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
21429 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
21430 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
21431 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21432 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
21433 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21434 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
21435 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21436 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
21437 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
21438 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
21439 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
21440 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
21441 { (char *)"Cursor_GetHandle", (PyCFunction) _wrap_Cursor_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21442 { (char *)"Cursor_SetHandle", (PyCFunction) _wrap_Cursor_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21443 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21444 { (char *)"Cursor_GetWidth", (PyCFunction) _wrap_Cursor_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21445 { (char *)"Cursor_GetHeight", (PyCFunction) _wrap_Cursor_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21446 { (char *)"Cursor_GetDepth", (PyCFunction) _wrap_Cursor_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21447 { (char *)"Cursor_SetWidth", (PyCFunction) _wrap_Cursor_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21448 { (char *)"Cursor_SetHeight", (PyCFunction) _wrap_Cursor_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21449 { (char *)"Cursor_SetDepth", (PyCFunction) _wrap_Cursor_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21450 { (char *)"Cursor_SetSize", (PyCFunction) _wrap_Cursor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21451 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
21452 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
21453 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21454 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
21455 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
21456 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
21457 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21458 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
21459 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
21460 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21461 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
21462 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
21463 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
21464 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
21465 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
21466 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21467 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
21468 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
21469 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
21470 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21471 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
21472 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
21473 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21474 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
21475 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
21476 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21477 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21478 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21479 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
21480 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
21481 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
21482 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
21483 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
21484 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
21485 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
21486 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21487 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
21488 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21489 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
21490 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
21491 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
21492 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
21493 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
21494 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
21495 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21496 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21497 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21498 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
21499 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21500 { (char *)"NativeFontInfo_GetPixelSize", (PyCFunction) _wrap_NativeFontInfo_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21501 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21502 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21503 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21504 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21505 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21506 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21507 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21508 { (char *)"NativeFontInfo_SetPixelSize", (PyCFunction) _wrap_NativeFontInfo_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21509 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21510 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21511 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21512 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21513 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21514 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21515 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
21516 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
21517 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
21518 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21519 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21520 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
21521 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
21522 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
21523 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
21524 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
21525 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21526 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21527 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
21528 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
21529 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
21530 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21531 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21532 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21533 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21534 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21535 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21536 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21537 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
21538 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21539 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21540 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
21541 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
21542 { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
21543 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21544 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21545 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21546 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
21547 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
21548 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
21549 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
21550 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21551 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21552 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21553 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
21554 { (char *)"new_Font2", (PyCFunction) _wrap_new_Font2, METH_VARARGS | METH_KEYWORDS, NULL},
21555 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21556 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21557 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21558 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21559 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21560 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21561 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
21562 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21563 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21564 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21565 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21566 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21567 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21568 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21569 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21570 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21571 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21572 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21573 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21574 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21575 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21576 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21577 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21578 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21579 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21580 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21581 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
21582 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21583 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
21584 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
21585 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
21586 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21587 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21588 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21589 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21590 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
21591 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21592 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21593 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21594 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21595 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21596 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21597 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21598 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
21599 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
21600 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
21601 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
21602 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
21603 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
21604 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
21605 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
21606 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21607 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21608 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
21609 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
21610 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21611 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21612 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21613 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21614 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21615 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21616 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
21617 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
21618 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
21619 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
21620 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
21621 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21622 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
21623 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21624 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21625 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
21626 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
21627 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
21628 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21629 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
21630 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21631 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21632 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21633 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
21634 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21635 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21636 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
21637 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
21638 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
21639 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21640 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21641 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
21642 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21643 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21644 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21645 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
21646 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21647 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
21648 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21649 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
21650 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21651 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
21652 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
21653 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
21654 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21655 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21656 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21657 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21658 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21659 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21660 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21661 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21662 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21663 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
21664 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21665 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
21666 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
21667 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21668 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21669 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21670 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21671 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21672 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
21673 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21674 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
21675 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21676 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
21677 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21678 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21679 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21680 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21681 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21682 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
21683 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
21684 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21685 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21686 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
21687 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21688 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21689 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21690 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
21691 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
21692 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21693 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21694 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21695 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21696 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21697 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21698 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21699 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21700 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21701 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21702 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21703 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21704 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21705 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21706 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
21707 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21708 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21709 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
21710 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21711 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
21712 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
21713 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21714 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21715 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
21716 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
21717 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21718 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21719 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21720 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21721 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21722 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
21723 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21724 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21725 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21726 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21727 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21728 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21729 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21730 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21731 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21732 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21733 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21734 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21735 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21736 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21737 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21738 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21739 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21740 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21741 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21742 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21743 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21744 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21745 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21746 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21747 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
21748 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21749 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21750 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21751 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21752 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21753 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21754 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
21755 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
21756 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
21757 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
21758 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21759 { (char *)"DC_GetHDC", (PyCFunction) _wrap_DC_GetHDC, METH_VARARGS | METH_KEYWORDS, NULL},
21760 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
21761 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
21762 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
21763 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
21764 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
21765 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
21766 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
21767 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
21768 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
21769 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
21770 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
21771 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
21772 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
21773 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
21774 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
21775 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21776 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
21777 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
21778 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
21779 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21780 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21781 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
21782 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
21783 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
21784 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21785 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
21786 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
21787 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
21788 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
21789 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
21790 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
21791 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21792 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21793 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21794 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21795 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
21796 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21797 { (char *)"delete_MetaFile", (PyCFunction) _wrap_delete_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21798 { (char *)"MetaFile_Ok", (PyCFunction) _wrap_MetaFile_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21799 { (char *)"MetaFile_SetClipboard", (PyCFunction) _wrap_MetaFile_SetClipboard, METH_VARARGS | METH_KEYWORDS, NULL},
21800 { (char *)"MetaFile_GetSize", (PyCFunction) _wrap_MetaFile_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21801 { (char *)"MetaFile_GetWidth", (PyCFunction) _wrap_MetaFile_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21802 { (char *)"MetaFile_GetHeight", (PyCFunction) _wrap_MetaFile_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21803 { (char *)"MetaFile_GetFileName", (PyCFunction) _wrap_MetaFile_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21804 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
21805 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
21806 { (char *)"MetaFileDC_Close", (PyCFunction) _wrap_MetaFileDC_Close, METH_VARARGS | METH_KEYWORDS, NULL},
21807 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
21808 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
21809 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
21810 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21811 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21812 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
21813 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
21814 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21815 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
21816 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
21817 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
21818 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
21819 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
21820 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21821 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
21822 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
21823 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
21824 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
21825 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21826 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
21827 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21828 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21829 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21830 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21831 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
21832 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21833 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21834 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
21835 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
21836 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
21837 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
21838 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
21839 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
21840 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
21841 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
21842 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21843 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
21844 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
21845 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21846 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21847 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21848 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21849 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21850 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21851 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21852 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21853 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21854 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21855 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21856 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
21857 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21858 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
21859 { NULL, NULL, 0, NULL }
21860 };
21861
21862
21863 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21864
21865 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
21866 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
21867 }
21868 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
21869 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
21870 }
21871 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
21872 return (void *)((wxGDIObject *) ((wxIcon *) x));
21873 }
21874 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
21875 return (void *)((wxGDIObject *) ((wxPalette *) x));
21876 }
21877 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
21878 return (void *)((wxGDIObject *) ((wxPen *) x));
21879 }
21880 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
21881 return (void *)((wxGDIObject *) ((wxFont *) x));
21882 }
21883 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
21884 return (void *)((wxGDIObject *) ((wxCursor *) x));
21885 }
21886 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
21887 return (void *)((wxGDIObject *) ((wxBitmap *) x));
21888 }
21889 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
21890 return (void *)((wxGDIObject *) ((wxRegion *) x));
21891 }
21892 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
21893 return (void *)((wxGDIObject *) ((wxBrush *) x));
21894 }
21895 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
21896 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
21897 }
21898 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
21899 return (void *)((wxDC *) ((wxScreenDC *) x));
21900 }
21901 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
21902 return (void *)((wxDC *) ((wxMirrorDC *) x));
21903 }
21904 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
21905 return (void *)((wxDC *) ((wxMemoryDC *) x));
21906 }
21907 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
21908 return (void *)((wxDC *) ((wxWindowDC *) x));
21909 }
21910 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
21911 return (void *)((wxDC *) ((wxMetaFileDC *) x));
21912 }
21913 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
21914 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21915 }
21916 static void *_p_wxClientDCTo_p_wxDC(void *x) {
21917 return (void *)((wxDC *) ((wxClientDC *) x));
21918 }
21919 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
21920 return (void *)((wxDC *) ((wxPaintDC *) x));
21921 }
21922 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
21923 return (void *)((wxDC *) ((wxPostScriptDC *) x));
21924 }
21925 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
21926 return (void *)((wxDC *) ((wxPrinterDC *) x));
21927 }
21928 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
21929 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
21930 }
21931 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21932 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21933 }
21934 static void *_p_wxPenTo_p_wxObject(void *x) {
21935 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
21936 }
21937 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
21938 return (void *)((wxObject *) ((wxRegionIterator *) x));
21939 }
21940 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21941 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21942 }
21943 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21944 return (void *)((wxObject *) ((wxSizerItem *) x));
21945 }
21946 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
21947 return (void *)((wxObject *) ((wxColourDatabase *) x));
21948 }
21949 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21950 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21951 }
21952 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21953 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21954 }
21955 static void *_p_wxIconTo_p_wxObject(void *x) {
21956 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
21957 }
21958 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21959 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21960 }
21961 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21962 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21963 }
21964 static void *_p_wxSizerTo_p_wxObject(void *x) {
21965 return (void *)((wxObject *) ((wxSizer *) x));
21966 }
21967 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21968 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21969 }
21970 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21971 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21972 }
21973 static void *_p_wxPenListTo_p_wxObject(void *x) {
21974 return (void *)((wxObject *) ((wxPenList *) x));
21975 }
21976 static void *_p_wxEventTo_p_wxObject(void *x) {
21977 return (void *)((wxObject *) ((wxEvent *) x));
21978 }
21979 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21980 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21981 }
21982 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21983 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21984 }
21985 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21986 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21987 }
21988 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21989 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21990 }
21991 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21992 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21993 }
21994 static void *_p_wxDCTo_p_wxObject(void *x) {
21995 return (void *)((wxObject *) ((wxDC *) x));
21996 }
21997 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21998 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21999 }
22000 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
22001 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
22002 }
22003 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
22004 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
22005 }
22006 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
22007 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
22008 }
22009 static void *_p_wxControlTo_p_wxObject(void *x) {
22010 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
22011 }
22012 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
22013 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
22014 }
22015 static void *_p_wxClientDCTo_p_wxObject(void *x) {
22016 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
22017 }
22018 static void *_p_wxFSFileTo_p_wxObject(void *x) {
22019 return (void *)((wxObject *) ((wxFSFile *) x));
22020 }
22021 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
22022 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
22023 }
22024 static void *_p_wxRegionTo_p_wxObject(void *x) {
22025 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
22026 }
22027 static void *_p_wxPySizerTo_p_wxObject(void *x) {
22028 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
22029 }
22030 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
22031 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
22032 }
22033 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
22034 return (void *)((wxObject *) ((wxGDIObject *) x));
22035 }
22036 static void *_p_wxEffectsTo_p_wxObject(void *x) {
22037 return (void *)((wxObject *) ((wxEffects *) x));
22038 }
22039 static void *_p_wxPyEventTo_p_wxObject(void *x) {
22040 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
22041 }
22042 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
22043 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
22044 }
22045 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
22046 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
22047 }
22048 static void *_p_wxShowEventTo_p_wxObject(void *x) {
22049 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
22050 }
22051 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
22052 return (void *)((wxObject *) ((wxMenuItem *) x));
22053 }
22054 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
22055 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
22056 }
22057 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
22058 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
22059 }
22060 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
22061 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
22062 }
22063 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
22064 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
22065 }
22066 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
22067 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
22068 }
22069 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
22070 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
22071 }
22072 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
22073 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
22074 }
22075 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
22076 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
22077 }
22078 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
22079 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
22080 }
22081 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
22082 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
22083 }
22084 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
22085 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
22086 }
22087 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
22088 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
22089 }
22090 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
22091 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
22092 }
22093 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
22094 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
22095 }
22096 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
22097 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
22098 }
22099 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
22100 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
22101 }
22102 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
22103 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
22104 }
22105 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
22106 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
22107 }
22108 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
22109 return (void *)((wxObject *) ((wxImageHandler *) x));
22110 }
22111 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
22112 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
22113 }
22114 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
22115 return (void *)((wxObject *) ((wxEvtHandler *) x));
22116 }
22117 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
22118 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
22119 }
22120 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
22121 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
22122 }
22123 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
22124 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
22125 }
22126 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
22127 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
22128 }
22129 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
22130 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
22131 }
22132 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
22133 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
22134 }
22135 static void *_p_wxImageTo_p_wxObject(void *x) {
22136 return (void *)((wxObject *) ((wxImage *) x));
22137 }
22138 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
22139 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
22140 }
22141 static void *_p_wxPaletteTo_p_wxObject(void *x) {
22142 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
22143 }
22144 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
22145 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
22146 }
22147 static void *_p_wxImageListTo_p_wxObject(void *x) {
22148 return (void *)((wxObject *) ((wxImageList *) x));
22149 }
22150 static void *_p_wxCursorTo_p_wxObject(void *x) {
22151 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
22152 }
22153 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
22154 return (void *)((wxObject *) ((wxEncodingConverter *) x));
22155 }
22156 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
22157 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
22158 }
22159 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
22160 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
22161 }
22162 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
22163 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
22164 }
22165 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
22166 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
22167 }
22168 static void *_p_wxWindowTo_p_wxObject(void *x) {
22169 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
22170 }
22171 static void *_p_wxMenuTo_p_wxObject(void *x) {
22172 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
22173 }
22174 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
22175 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
22176 }
22177 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
22178 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
22179 }
22180 static void *_p_wxBrushListTo_p_wxObject(void *x) {
22181 return (void *)((wxObject *) ((wxBrushList *) x));
22182 }
22183 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
22184 return (void *)((wxObject *) ((wxFileSystem *) x));
22185 }
22186 static void *_p_wxBitmapTo_p_wxObject(void *x) {
22187 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
22188 }
22189 static void *_p_wxMaskTo_p_wxObject(void *x) {
22190 return (void *)((wxObject *) ((wxMask *) x));
22191 }
22192 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
22193 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
22194 }
22195 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
22196 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
22197 }
22198 static void *_p_wxPyAppTo_p_wxObject(void *x) {
22199 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
22200 }
22201 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
22202 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
22203 }
22204 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
22205 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
22206 }
22207 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
22208 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
22209 }
22210 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
22211 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
22212 }
22213 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
22214 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
22215 }
22216 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
22217 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
22218 }
22219 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
22220 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
22221 }
22222 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
22223 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
22224 }
22225 static void *_p_wxFontTo_p_wxObject(void *x) {
22226 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
22227 }
22228 static void *_p_wxBrushTo_p_wxObject(void *x) {
22229 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
22230 }
22231 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
22232 return (void *)((wxObject *) ((wxMetaFile *) x));
22233 }
22234 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
22235 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
22236 }
22237 static void *_p_wxColourTo_p_wxObject(void *x) {
22238 return (void *)((wxObject *) ((wxColour *) x));
22239 }
22240 static void *_p_wxFontListTo_p_wxObject(void *x) {
22241 return (void *)((wxObject *) ((wxFontList *) x));
22242 }
22243 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
22244 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
22245 }
22246 static void *_p_wxValidatorTo_p_wxObject(void *x) {
22247 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
22248 }
22249 static void *_p_wxControlTo_p_wxWindow(void *x) {
22250 return (void *)((wxWindow *) ((wxControl *) x));
22251 }
22252 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
22253 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
22254 }
22255 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
22256 return (void *)((wxWindow *) ((wxMenuBar *) x));
22257 }
22258 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}};
22259 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}};
22260 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}};
22261 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}};
22262 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}};
22263 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}};
22264 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}};
22265 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}};
22266 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}};
22267 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}};
22268 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}};
22269 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}};
22270 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}};
22271 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}};
22272 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}};
22273 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}};
22274 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}};
22275 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}};
22276 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}};
22277 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}};
22278 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}};
22279 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}};
22280 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}};
22281 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxRegionIterator", _p_wxRegionIteratorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPen", _p_wxPenTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColourDatabase", _p_wxColourDatabaseTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPenList", _p_wxPenListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMask", _p_wxMaskTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFont", _p_wxFontTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClientDC", _p_wxClientDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMemoryDC", _p_wxMemoryDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxRegion", _p_wxRegionTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDC", _p_wxDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIcon", _p_wxIconTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDC", _p_wxWindowDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGDIObject", _p_wxGDIObjectTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEffects", _p_wxEffectsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPostScriptDC", _p_wxPostScriptDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintDC", _p_wxPaintDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBufferedPaintDC", _p_wxBufferedPaintDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrinterDC", _p_wxPrinterDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScreenDC", _p_wxScreenDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBufferedDC", _p_wxBufferedDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPalette", _p_wxPaletteTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageList", _p_wxImageListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCursor", _p_wxCursorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxMirrorDC", _p_wxMirrorDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEncodingConverter", _p_wxEncodingConverterTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMetaFileDC", _p_wxMetaFileDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBrushList", _p_wxBrushListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBitmap", _p_wxBitmapTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBrush", _p_wxBrushTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMetaFile", _p_wxMetaFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColour", _p_wxColourTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFontList", _p_wxFontListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
22282 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}};
22283 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}};
22284 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}};
22285 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}};
22286 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}};
22287 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}};
22288 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}};
22289 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}};
22290 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}};
22291 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}};
22292 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}};
22293 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}};
22294 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}};
22295 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}};
22296 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}};
22297 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}};
22298 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}};
22299 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}};
22300 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}};
22301 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}};
22302 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}};
22303 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}};
22304 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}};
22305 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}};
22306 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}};
22307 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}};
22308 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}};
22309 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}};
22310 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}};
22311 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}};
22312 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}};
22313 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}};
22314 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}};
22315 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}};
22316 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}};
22317 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}};
22318 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}};
22319 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}};
22320
22321 static swig_type_info *swig_types_initial[] = {
22322 _swigt__p_wxPostScriptDC,
22323 _swigt__p_wxBrush,
22324 _swigt__p_wxColour,
22325 _swigt__p_wxDC,
22326 _swigt__p_wxMirrorDC,
22327 _swigt__p_form_ops_t,
22328 _swigt__p_wxDuplexMode,
22329 _swigt__p_wxPyFontEnumerator,
22330 _swigt__p_char,
22331 _swigt__p_wxIconLocation,
22332 _swigt__p_wxImage,
22333 _swigt__p_wxMetaFileDC,
22334 _swigt__p_wxMask,
22335 _swigt__p_wxSize,
22336 _swigt__p_wxFont,
22337 _swigt__p_wxWindow,
22338 _swigt__p_double,
22339 _swigt__p_wxMemoryDC,
22340 _swigt__p_wxFontMapper,
22341 _swigt__p_wxEffects,
22342 _swigt__p_wxNativeEncodingInfo,
22343 _swigt__p_wxPalette,
22344 _swigt__p_wxBitmap,
22345 _swigt__p_wxObject,
22346 _swigt__p_wxRegionIterator,
22347 _swigt__p_wxRect,
22348 _swigt__p_wxPaperSize,
22349 _swigt__p_wxString,
22350 _swigt__unsigned_int,
22351 _swigt__p_unsigned_int,
22352 _swigt__p_wxPrinterDC,
22353 _swigt__p_wxIconBundle,
22354 _swigt__p_wxPoint,
22355 _swigt__p_wxDash,
22356 _swigt__p_wxScreenDC,
22357 _swigt__p_wxCursor,
22358 _swigt__p_wxClientDC,
22359 _swigt__p_wxBufferedDC,
22360 _swigt__p_wxImageList,
22361 _swigt__p_unsigned_char,
22362 _swigt__p_wxGDIObject,
22363 _swigt__p_wxIcon,
22364 _swigt__p_wxLocale,
22365 _swigt__ptrdiff_t,
22366 _swigt__std__ptrdiff_t,
22367 _swigt__p_wxRegion,
22368 _swigt__p_wxConfigBase,
22369 _swigt__p_wxLanguageInfo,
22370 _swigt__p_wxWindowDC,
22371 _swigt__p_wxPrintData,
22372 _swigt__p_wxBrushList,
22373 _swigt__p_wxFontList,
22374 _swigt__p_wxPen,
22375 _swigt__p_wxBufferedPaintDC,
22376 _swigt__p_wxPaintDC,
22377 _swigt__p_wxPenList,
22378 _swigt__p_int,
22379 _swigt__p_wxMetaFile,
22380 _swigt__p_unsigned_long,
22381 _swigt__p_wxNativeFontInfo,
22382 _swigt__p_wxEncodingConverter,
22383 _swigt__p_wxColourDatabase,
22384 0
22385 };
22386
22387
22388 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22389
22390 static swig_const_info swig_const_table[] = {
22391 {0, 0, 0, 0.0, 0, 0}};
22392
22393 #ifdef __cplusplus
22394 }
22395 #endif
22396
22397
22398 #ifdef __cplusplus
22399 extern "C" {
22400 #endif
22401
22402 /* Python-specific SWIG API */
22403 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22404 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22405 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22406
22407 /* -----------------------------------------------------------------------------
22408 * global variable support code.
22409 * ----------------------------------------------------------------------------- */
22410
22411 typedef struct swig_globalvar {
22412 char *name; /* Name of global variable */
22413 PyObject *(*get_attr)(); /* Return the current value */
22414 int (*set_attr)(PyObject *); /* Set the value */
22415 struct swig_globalvar *next;
22416 } swig_globalvar;
22417
22418 typedef struct swig_varlinkobject {
22419 PyObject_HEAD
22420 swig_globalvar *vars;
22421 } swig_varlinkobject;
22422
22423 static PyObject *
22424 swig_varlink_repr(swig_varlinkobject *v) {
22425 v = v;
22426 return PyString_FromString("<Swig global variables>");
22427 }
22428
22429 static int
22430 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
22431 swig_globalvar *var;
22432 flags = flags;
22433 fprintf(fp,"Swig global variables { ");
22434 for (var = v->vars; var; var=var->next) {
22435 fprintf(fp,"%s", var->name);
22436 if (var->next) fprintf(fp,", ");
22437 }
22438 fprintf(fp," }\n");
22439 return 0;
22440 }
22441
22442 static PyObject *
22443 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
22444 swig_globalvar *var = v->vars;
22445 while (var) {
22446 if (strcmp(var->name,n) == 0) {
22447 return (*var->get_attr)();
22448 }
22449 var = var->next;
22450 }
22451 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22452 return NULL;
22453 }
22454
22455 static int
22456 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22457 swig_globalvar *var = v->vars;
22458 while (var) {
22459 if (strcmp(var->name,n) == 0) {
22460 return (*var->set_attr)(p);
22461 }
22462 var = var->next;
22463 }
22464 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22465 return 1;
22466 }
22467
22468 static PyTypeObject varlinktype = {
22469 PyObject_HEAD_INIT(0)
22470 0, /* Number of items in variable part (ob_size) */
22471 (char *)"swigvarlink", /* Type name (tp_name) */
22472 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
22473 0, /* Itemsize (tp_itemsize) */
22474 0, /* Deallocator (tp_dealloc) */
22475 (printfunc) swig_varlink_print, /* Print (tp_print) */
22476 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
22477 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
22478 0, /* tp_compare */
22479 (reprfunc) swig_varlink_repr, /* tp_repr */
22480 0, /* tp_as_number */
22481 0, /* tp_as_sequence */
22482 0, /* tp_as_mapping */
22483 0, /* tp_hash */
22484 0, /* tp_call */
22485 0, /* tp_str */
22486 0, /* tp_getattro */
22487 0, /* tp_setattro */
22488 0, /* tp_as_buffer */
22489 0, /* tp_flags */
22490 0, /* tp_doc */
22491 #if PY_VERSION_HEX >= 0x02000000
22492 0, /* tp_traverse */
22493 0, /* tp_clear */
22494 #endif
22495 #if PY_VERSION_HEX >= 0x02010000
22496 0, /* tp_richcompare */
22497 0, /* tp_weaklistoffset */
22498 #endif
22499 #if PY_VERSION_HEX >= 0x02020000
22500 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22501 #endif
22502 #if PY_VERSION_HEX >= 0x02030000
22503 0, /* tp_del */
22504 #endif
22505 #ifdef COUNT_ALLOCS
22506 0,0,0,0 /* tp_alloc -> tp_next */
22507 #endif
22508 };
22509
22510 /* Create a variable linking object for use later */
22511 static PyObject *
22512 SWIG_Python_newvarlink(void) {
22513 swig_varlinkobject *result = 0;
22514 result = PyMem_NEW(swig_varlinkobject,1);
22515 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
22516 result->ob_type = &varlinktype;
22517 result->vars = 0;
22518 result->ob_refcnt = 0;
22519 Py_XINCREF((PyObject *) result);
22520 return ((PyObject*) result);
22521 }
22522
22523 static void
22524 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22525 swig_varlinkobject *v;
22526 swig_globalvar *gv;
22527 v= (swig_varlinkobject *) p;
22528 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22529 gv->name = (char *) malloc(strlen(name)+1);
22530 strcpy(gv->name,name);
22531 gv->get_attr = get_attr;
22532 gv->set_attr = set_attr;
22533 gv->next = v->vars;
22534 v->vars = gv;
22535 }
22536
22537 /* -----------------------------------------------------------------------------
22538 * constants/methods manipulation
22539 * ----------------------------------------------------------------------------- */
22540
22541 /* Install Constants */
22542 static void
22543 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22544 PyObject *obj = 0;
22545 size_t i;
22546 for (i = 0; constants[i].type; i++) {
22547 switch(constants[i].type) {
22548 case SWIG_PY_INT:
22549 obj = PyInt_FromLong(constants[i].lvalue);
22550 break;
22551 case SWIG_PY_FLOAT:
22552 obj = PyFloat_FromDouble(constants[i].dvalue);
22553 break;
22554 case SWIG_PY_STRING:
22555 if (constants[i].pvalue) {
22556 obj = PyString_FromString((char *) constants[i].pvalue);
22557 } else {
22558 Py_INCREF(Py_None);
22559 obj = Py_None;
22560 }
22561 break;
22562 case SWIG_PY_POINTER:
22563 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22564 break;
22565 case SWIG_PY_BINARY:
22566 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22567 break;
22568 default:
22569 obj = 0;
22570 break;
22571 }
22572 if (obj) {
22573 PyDict_SetItemString(d,constants[i].name,obj);
22574 Py_DECREF(obj);
22575 }
22576 }
22577 }
22578
22579 /* -----------------------------------------------------------------------------*/
22580 /* Fix SwigMethods to carry the callback ptrs when needed */
22581 /* -----------------------------------------------------------------------------*/
22582
22583 static void
22584 SWIG_Python_FixMethods(PyMethodDef *methods,
22585 swig_const_info *const_table,
22586 swig_type_info **types,
22587 swig_type_info **types_initial) {
22588 size_t i;
22589 for (i = 0; methods[i].ml_name; ++i) {
22590 char *c = methods[i].ml_doc;
22591 if (c && (c = strstr(c, "swig_ptr: "))) {
22592 int j;
22593 swig_const_info *ci = 0;
22594 char *name = c + 10;
22595 for (j = 0; const_table[j].type; j++) {
22596 if (strncmp(const_table[j].name, name,
22597 strlen(const_table[j].name)) == 0) {
22598 ci = &(const_table[j]);
22599 break;
22600 }
22601 }
22602 if (ci) {
22603 size_t shift = (ci->ptype) - types;
22604 swig_type_info *ty = types_initial[shift];
22605 size_t ldoc = (c - methods[i].ml_doc);
22606 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22607 char *ndoc = (char*)malloc(ldoc + lptr + 10);
22608 char *buff = ndoc;
22609 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
22610 strncpy(buff, methods[i].ml_doc, ldoc);
22611 buff += ldoc;
22612 strncpy(buff, "swig_ptr: ", 10);
22613 buff += 10;
22614 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22615 methods[i].ml_doc = ndoc;
22616 }
22617 }
22618 }
22619 }
22620
22621 /* -----------------------------------------------------------------------------*
22622 * Initialize type list
22623 * -----------------------------------------------------------------------------*/
22624
22625 #if PY_MAJOR_VERSION < 2
22626 /* PyModule_AddObject function was introduced in Python 2.0. The following function
22627 is copied out of Python/modsupport.c in python version 2.3.4 */
22628 static int
22629 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
22630 {
22631 PyObject *dict;
22632 if (!PyModule_Check(m)) {
22633 PyErr_SetString(PyExc_TypeError,
22634 "PyModule_AddObject() needs module as first arg");
22635 return -1;
22636 }
22637 if (!o) {
22638 PyErr_SetString(PyExc_TypeError,
22639 "PyModule_AddObject() needs non-NULL value");
22640 return -1;
22641 }
22642
22643 dict = PyModule_GetDict(m);
22644 if (dict == NULL) {
22645 /* Internal error -- modules must have a dict! */
22646 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
22647 PyModule_GetName(m));
22648 return -1;
22649 }
22650 if (PyDict_SetItemString(dict, name, o))
22651 return -1;
22652 Py_DECREF(o);
22653 return 0;
22654 }
22655 #endif
22656
22657 static swig_type_info **
22658 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
22659 static PyMethodDef swig_empty_runtime_method_table[] = {
22660 {
22661 NULL, NULL, 0, NULL
22662 }
22663 };/* Sentinel */
22664
22665 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
22666 swig_empty_runtime_method_table);
22667 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
22668 if (pointer && module) {
22669 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
22670 }
22671 return type_list_handle;
22672 }
22673
22674 static swig_type_info **
22675 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
22676 swig_type_info **type_pointer;
22677
22678 /* first check if module already created */
22679 type_pointer = SWIG_Python_GetTypeListHandle();
22680 if (type_pointer) {
22681 return type_pointer;
22682 } else {
22683 /* create a new module and variable */
22684 return SWIG_Python_SetTypeListHandle(type_list_handle);
22685 }
22686 }
22687
22688 #ifdef __cplusplus
22689 }
22690 #endif
22691
22692 /* -----------------------------------------------------------------------------*
22693 * Partial Init method
22694 * -----------------------------------------------------------------------------*/
22695
22696 #ifdef SWIG_LINK_RUNTIME
22697 #ifdef __cplusplus
22698 extern "C"
22699 #endif
22700 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
22701 #endif
22702
22703 #ifdef __cplusplus
22704 extern "C"
22705 #endif
22706 SWIGEXPORT(void) SWIG_init(void) {
22707 static PyObject *SWIG_globals = 0;
22708 static int typeinit = 0;
22709 PyObject *m, *d;
22710 int i;
22711 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
22712
22713 /* Fix SwigMethods to carry the callback ptrs when needed */
22714 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
22715
22716 m = Py_InitModule((char *) SWIG_name, SwigMethods);
22717 d = PyModule_GetDict(m);
22718
22719 if (!typeinit) {
22720 #ifdef SWIG_LINK_RUNTIME
22721 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
22722 #else
22723 # ifndef SWIG_STATIC_RUNTIME
22724 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
22725 # endif
22726 #endif
22727 for (i = 0; swig_types_initial[i]; i++) {
22728 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
22729 }
22730 typeinit = 1;
22731 }
22732 SWIG_InstallConstants(d,swig_const_table);
22733
22734 {
22735 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
22736 }
22737 {
22738 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
22739 }
22740 {
22741 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
22742 }
22743 {
22744 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
22745 }
22746 {
22747 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
22748 }
22749 {
22750 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
22751 }
22752 {
22753 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
22754 }
22755 {
22756 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
22757 }
22758 {
22759 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
22760 }
22761 {
22762 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
22763 }
22764 {
22765 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
22766 }
22767 {
22768 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
22769 }
22770 {
22771 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
22772 }
22773 {
22774 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
22775 }
22776 {
22777 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
22778 }
22779 {
22780 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
22781 }
22782 {
22783 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
22784 }
22785 {
22786 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
22787 }
22788 {
22789 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
22790 }
22791 {
22792 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
22793 }
22794 {
22795 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
22796 }
22797 {
22798 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
22799 }
22800 {
22801 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
22802 }
22803 {
22804 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
22805 }
22806 {
22807 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
22808 }
22809 {
22810 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
22811 }
22812 {
22813 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
22814 }
22815 {
22816 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
22817 }
22818 {
22819 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
22820 }
22821 {
22822 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
22823 }
22824 {
22825 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
22826 }
22827 {
22828 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
22829 }
22830 {
22831 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
22832 }
22833 {
22834 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
22835 }
22836 {
22837 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
22838 }
22839 {
22840 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
22841 }
22842 {
22843 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
22844 }
22845 {
22846 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
22847 }
22848 {
22849 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
22850 }
22851 {
22852 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
22853 }
22854 {
22855 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
22856 }
22857 {
22858 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
22859 }
22860 {
22861 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
22862 }
22863 {
22864 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
22865 }
22866 {
22867 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
22868 }
22869 {
22870 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
22871 }
22872 {
22873 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
22874 }
22875 {
22876 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
22877 }
22878 {
22879 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
22880 }
22881 {
22882 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
22883 }
22884 {
22885 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
22886 }
22887 {
22888 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
22889 }
22890 {
22891 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
22892 }
22893 {
22894 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
22895 }
22896 {
22897 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
22898 }
22899 {
22900 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
22901 }
22902 {
22903 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
22904 }
22905 {
22906 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
22907 }
22908 {
22909 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
22910 }
22911 {
22912 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
22913 }
22914 {
22915 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
22916 }
22917 {
22918 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
22919 }
22920 {
22921 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
22922 }
22923 {
22924 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
22925 }
22926 {
22927 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
22928 }
22929 {
22930 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
22931 }
22932 {
22933 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
22934 }
22935 {
22936 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
22937 }
22938 {
22939 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
22940 }
22941 {
22942 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
22943 }
22944 {
22945 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
22946 }
22947 {
22948 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
22949 }
22950 {
22951 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
22952 }
22953 {
22954 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
22955 }
22956 {
22957 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
22958 }
22959 {
22960 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
22961 }
22962 {
22963 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
22964 }
22965 {
22966 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
22967 }
22968 {
22969 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
22970 }
22971 {
22972 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
22973 }
22974 {
22975 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
22976 }
22977 {
22978 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
22979 }
22980 {
22981 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
22982 }
22983 {
22984 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
22985 }
22986 {
22987 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
22988 }
22989 {
22990 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
22991 }
22992 {
22993 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
22994 }
22995 {
22996 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
22997 }
22998 {
22999 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
23000 }
23001 {
23002 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
23003 }
23004 {
23005 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
23006 }
23007 {
23008 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
23009 }
23010 {
23011 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
23012 }
23013 {
23014 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
23015 }
23016 {
23017 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
23018 }
23019 {
23020 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
23021 }
23022 {
23023 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
23024 }
23025 {
23026 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
23027 }
23028 {
23029 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
23030 }
23031 {
23032 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
23033 }
23034 {
23035 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
23036 }
23037 {
23038 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
23039 }
23040 {
23041 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
23042 }
23043 {
23044 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
23045 }
23046 {
23047 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
23048 }
23049 {
23050 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
23051 }
23052 {
23053 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
23054 }
23055 {
23056 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
23057 }
23058 {
23059 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
23060 }
23061 {
23062 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
23063 }
23064 {
23065 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
23066 }
23067 {
23068 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
23069 }
23070 {
23071 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
23072 }
23073 {
23074 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
23075 }
23076 {
23077 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
23078 }
23079 {
23080 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
23081 }
23082 {
23083 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
23084 }
23085 {
23086 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
23087 }
23088 {
23089 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
23090 }
23091 {
23092 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
23093 }
23094 {
23095 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
23096 }
23097 {
23098 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
23099 }
23100 {
23101 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
23102 }
23103 {
23104 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
23105 }
23106 {
23107 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
23108 }
23109 {
23110 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
23111 }
23112 {
23113 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
23114 }
23115
23116 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
23117
23118 {
23119 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
23120 }
23121 {
23122 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
23123 }
23124 {
23125 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
23126 }
23127 {
23128 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
23129 }
23130 {
23131 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
23132 }
23133 {
23134 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
23135 }
23136 {
23137 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
23138 }
23139 {
23140 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
23141 }
23142 {
23143 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
23144 }
23145 {
23146 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
23147 }
23148 {
23149 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
23150 }
23151 {
23152 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
23153 }
23154 {
23155 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
23156 }
23157 {
23158 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
23159 }
23160 {
23161 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
23162 }
23163 {
23164 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
23165 }
23166 {
23167 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
23168 }
23169 {
23170 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
23171 }
23172 {
23173 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
23174 }
23175 {
23176 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
23177 }
23178 {
23179 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
23180 }
23181 {
23182 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
23183 }
23184 {
23185 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
23186 }
23187 {
23188 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
23189 }
23190 {
23191 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
23192 }
23193 {
23194 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
23195 }
23196 {
23197 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
23198 }
23199 {
23200 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
23201 }
23202 {
23203 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
23204 }
23205 {
23206 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
23207 }
23208 {
23209 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
23210 }
23211 {
23212 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
23213 }
23214 {
23215 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
23216 }
23217 {
23218 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
23219 }
23220 {
23221 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
23222 }
23223 {
23224 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
23225 }
23226 {
23227 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
23228 }
23229 {
23230 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
23231 }
23232 {
23233 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
23234 }
23235 {
23236 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
23237 }
23238 {
23239 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
23240 }
23241 {
23242 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
23243 }
23244 {
23245 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
23246 }
23247 {
23248 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
23249 }
23250 {
23251 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
23252 }
23253 {
23254 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
23255 }
23256 {
23257 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
23258 }
23259 {
23260 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
23261 }
23262 {
23263 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
23264 }
23265 {
23266 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
23267 }
23268 {
23269 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
23270 }
23271 {
23272 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
23273 }
23274 {
23275 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
23276 }
23277 {
23278 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
23279 }
23280 {
23281 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
23282 }
23283 {
23284 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
23285 }
23286 {
23287 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
23288 }
23289 {
23290 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
23291 }
23292 {
23293 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
23294 }
23295 {
23296 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
23297 }
23298 {
23299 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
23300 }
23301 {
23302 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
23303 }
23304 {
23305 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
23306 }
23307 {
23308 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
23309 }
23310 {
23311 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
23312 }
23313 {
23314 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
23315 }
23316 {
23317 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
23318 }
23319 {
23320 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
23321 }
23322 {
23323 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
23324 }
23325 {
23326 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
23327 }
23328 {
23329 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
23330 }
23331 {
23332 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
23333 }
23334 {
23335 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
23336 }
23337 {
23338 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
23339 }
23340 {
23341 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
23342 }
23343 {
23344 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
23345 }
23346 {
23347 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
23348 }
23349 {
23350 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
23351 }
23352 {
23353 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
23354 }
23355 {
23356 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
23357 }
23358 {
23359 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
23360 }
23361 {
23362 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
23363 }
23364 {
23365 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
23366 }
23367 {
23368 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
23369 }
23370 {
23371 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
23372 }
23373 {
23374 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
23375 }
23376 {
23377 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
23378 }
23379 {
23380 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
23381 }
23382 {
23383 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
23384 }
23385 {
23386 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
23387 }
23388 {
23389 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
23390 }
23391 {
23392 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
23393 }
23394 {
23395 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
23396 }
23397 {
23398 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
23399 }
23400 {
23401 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
23402 }
23403 {
23404 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
23405 }
23406 {
23407 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
23408 }
23409 {
23410 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
23411 }
23412 {
23413 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
23414 }
23415 {
23416 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
23417 }
23418 {
23419 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
23420 }
23421 {
23422 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
23423 }
23424 {
23425 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
23426 }
23427 {
23428 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
23429 }
23430 {
23431 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
23432 }
23433 {
23434 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
23435 }
23436 {
23437 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
23438 }
23439 {
23440 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
23441 }
23442 {
23443 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
23444 }
23445 {
23446 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
23447 }
23448 {
23449 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
23450 }
23451 {
23452 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
23453 }
23454 {
23455 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
23456 }
23457 {
23458 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
23459 }
23460 {
23461 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
23462 }
23463 {
23464 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
23465 }
23466 {
23467 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
23468 }
23469 {
23470 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
23471 }
23472 {
23473 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
23474 }
23475 {
23476 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
23477 }
23478 {
23479 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
23480 }
23481 {
23482 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
23483 }
23484 {
23485 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
23486 }
23487 {
23488 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
23489 }
23490 {
23491 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
23492 }
23493 {
23494 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
23495 }
23496 {
23497 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
23498 }
23499 {
23500 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
23501 }
23502 {
23503 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
23504 }
23505 {
23506 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
23507 }
23508 {
23509 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
23510 }
23511 {
23512 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
23513 }
23514 {
23515 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
23516 }
23517 {
23518 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
23519 }
23520 {
23521 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
23522 }
23523 {
23524 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
23525 }
23526 {
23527 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
23528 }
23529 {
23530 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
23531 }
23532 {
23533 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
23534 }
23535 {
23536 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
23537 }
23538 {
23539 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
23540 }
23541 {
23542 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
23543 }
23544 {
23545 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
23546 }
23547 {
23548 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
23549 }
23550 {
23551 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
23552 }
23553 {
23554 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
23555 }
23556 {
23557 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
23558 }
23559 {
23560 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
23561 }
23562 {
23563 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
23564 }
23565 {
23566 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
23567 }
23568 {
23569 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
23570 }
23571 {
23572 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
23573 }
23574 {
23575 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
23576 }
23577 {
23578 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
23579 }
23580 {
23581 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
23582 }
23583 {
23584 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
23585 }
23586 {
23587 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
23588 }
23589 {
23590 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
23591 }
23592 {
23593 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
23594 }
23595 {
23596 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
23597 }
23598 {
23599 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
23600 }
23601 {
23602 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
23603 }
23604 {
23605 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
23606 }
23607 {
23608 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
23609 }
23610 {
23611 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
23612 }
23613 {
23614 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
23615 }
23616 {
23617 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
23618 }
23619 {
23620 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
23621 }
23622 {
23623 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
23624 }
23625 {
23626 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
23627 }
23628 {
23629 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
23630 }
23631 {
23632 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
23633 }
23634 {
23635 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
23636 }
23637 {
23638 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
23639 }
23640 {
23641 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
23642 }
23643 {
23644 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
23645 }
23646 {
23647 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
23648 }
23649 {
23650 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
23651 }
23652 {
23653 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
23654 }
23655 {
23656 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
23657 }
23658 {
23659 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
23660 }
23661 {
23662 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
23663 }
23664 {
23665 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
23666 }
23667 {
23668 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
23669 }
23670 {
23671 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
23672 }
23673 {
23674 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
23675 }
23676 {
23677 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
23678 }
23679 {
23680 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
23681 }
23682 {
23683 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
23684 }
23685 {
23686 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
23687 }
23688 {
23689 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
23690 }
23691 {
23692 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
23693 }
23694 {
23695 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
23696 }
23697 {
23698 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
23699 }
23700 {
23701 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
23702 }
23703 {
23704 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
23705 }
23706 {
23707 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
23708 }
23709 {
23710 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
23711 }
23712 {
23713 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
23714 }
23715 {
23716 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
23717 }
23718 {
23719 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
23720 }
23721 {
23722 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
23723 }
23724 {
23725 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
23726 }
23727 {
23728 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
23729 }
23730 {
23731 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
23732 }
23733 {
23734 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
23735 }
23736 {
23737 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
23738 }
23739 {
23740 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
23741 }
23742 {
23743 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
23744 }
23745 {
23746 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
23747 }
23748 {
23749 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
23750 }
23751 {
23752 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
23753 }
23754 {
23755 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
23756 }
23757 {
23758 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
23759 }
23760 {
23761 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
23762 }
23763 {
23764 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
23765 }
23766 {
23767 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
23768 }
23769 {
23770 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
23771 }
23772 {
23773 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
23774 }
23775 {
23776 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
23777 }
23778 {
23779 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
23780 }
23781 {
23782 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
23783 }
23784 {
23785 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
23786 }
23787 {
23788 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
23789 }
23790 {
23791 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
23792 }
23793 {
23794 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
23795 }
23796 {
23797 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
23798 }
23799 {
23800 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
23801 }
23802 {
23803 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
23804 }
23805 {
23806 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
23807 }
23808 {
23809 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
23810 }
23811 {
23812 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
23813 }
23814 {
23815 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
23816 }
23817 {
23818 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
23819 }
23820 {
23821 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
23822 }
23823 {
23824 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
23825 }
23826 {
23827 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
23828 }
23829 {
23830 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
23831 }
23832 {
23833 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
23834 }
23835 {
23836 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
23837 }
23838 {
23839 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
23840 }
23841 {
23842 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
23843 }
23844 {
23845 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
23846 }
23847 {
23848 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
23849 }
23850 {
23851 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
23852 }
23853 {
23854 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
23855 }
23856 {
23857 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
23858 }
23859 {
23860 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
23861 }
23862 {
23863 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
23864 }
23865 {
23866 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
23867 }
23868 {
23869 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
23870 }
23871 {
23872 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
23873 }
23874 {
23875 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
23876 }
23877 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
23878 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
23879 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
23880 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
23881 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
23882 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
23883 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
23884 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
23885 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
23886 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
23887 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
23888 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
23889 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
23890 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
23891 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
23892 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
23893 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
23894 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
23895 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
23896 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
23897 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
23898 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
23899 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
23900 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
23901 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
23902 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
23903 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
23904 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
23905 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
23906 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
23907 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
23908 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
23909 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
23910 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
23911 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
23912 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
23913 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
23914 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
23915 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
23916 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
23917 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
23918 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
23919 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
23920 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
23921 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
23922 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
23923 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
23924
23925 // Work around a chicken/egg problem in drawlist.cpp
23926 wxPyDrawList_SetAPIPtr();
23927
23928 }
23929
wxWidgets (Impactor)