]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_gdi_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Docview and IDE patch from Morag Hua with fix for bug #1217890
[wxWidgets.git] / wxPython / src / gtk / _gdi_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxPostScriptDC swig_types[0]
1343 #define SWIGTYPE_p_wxBrush swig_types[1]
1344 #define SWIGTYPE_p_wxColour swig_types[2]
1345 #define SWIGTYPE_p_wxDC swig_types[3]
1346 #define SWIGTYPE_p_wxMirrorDC swig_types[4]
1347 #define SWIGTYPE_p_form_ops_t swig_types[5]
1348 #define SWIGTYPE_p_wxDuplexMode swig_types[6]
1349 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[7]
1350 #define SWIGTYPE_p_char swig_types[8]
1351 #define SWIGTYPE_p_wxIconLocation swig_types[9]
1352 #define SWIGTYPE_p_wxImage swig_types[10]
1353 #define SWIGTYPE_p_wxMetaFileDC swig_types[11]
1354 #define SWIGTYPE_p_wxMask swig_types[12]
1355 #define SWIGTYPE_p_wxSize swig_types[13]
1356 #define SWIGTYPE_p_wxFont swig_types[14]
1357 #define SWIGTYPE_p_wxWindow swig_types[15]
1358 #define SWIGTYPE_p_double swig_types[16]
1359 #define SWIGTYPE_p_wxMemoryDC swig_types[17]
1360 #define SWIGTYPE_p_wxFontMapper swig_types[18]
1361 #define SWIGTYPE_p_wxEffects swig_types[19]
1362 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[20]
1363 #define SWIGTYPE_p_wxPalette swig_types[21]
1364 #define SWIGTYPE_p_wxBitmap swig_types[22]
1365 #define SWIGTYPE_p_wxObject swig_types[23]
1366 #define SWIGTYPE_p_wxRegionIterator swig_types[24]
1367 #define SWIGTYPE_p_wxRect swig_types[25]
1368 #define SWIGTYPE_p_wxPaperSize swig_types[26]
1369 #define SWIGTYPE_p_wxString swig_types[27]
1370 #define SWIGTYPE_unsigned_int swig_types[28]
1371 #define SWIGTYPE_p_unsigned_int swig_types[29]
1372 #define SWIGTYPE_p_wxPrinterDC swig_types[30]
1373 #define SWIGTYPE_p_wxIconBundle swig_types[31]
1374 #define SWIGTYPE_p_wxPoint swig_types[32]
1375 #define SWIGTYPE_p_wxDash swig_types[33]
1376 #define SWIGTYPE_p_wxScreenDC swig_types[34]
1377 #define SWIGTYPE_p_wxCursor swig_types[35]
1378 #define SWIGTYPE_p_wxClientDC swig_types[36]
1379 #define SWIGTYPE_p_wxBufferedDC swig_types[37]
1380 #define SWIGTYPE_p_wxImageList swig_types[38]
1381 #define SWIGTYPE_p_unsigned_char swig_types[39]
1382 #define SWIGTYPE_p_wxGDIObject swig_types[40]
1383 #define SWIGTYPE_p_wxIcon swig_types[41]
1384 #define SWIGTYPE_p_wxLocale swig_types[42]
1385 #define SWIGTYPE_ptrdiff_t swig_types[43]
1386 #define SWIGTYPE_std__ptrdiff_t swig_types[44]
1387 #define SWIGTYPE_p_wxRegion swig_types[45]
1388 #define SWIGTYPE_p_wxConfigBase swig_types[46]
1389 #define SWIGTYPE_p_wxLanguageInfo swig_types[47]
1390 #define SWIGTYPE_p_wxWindowDC swig_types[48]
1391 #define SWIGTYPE_p_wxPrintData swig_types[49]
1392 #define SWIGTYPE_p_wxBrushList swig_types[50]
1393 #define SWIGTYPE_p_wxFontList swig_types[51]
1394 #define SWIGTYPE_p_wxPen swig_types[52]
1395 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[53]
1396 #define SWIGTYPE_p_wxPaintDC swig_types[54]
1397 #define SWIGTYPE_p_wxPenList swig_types[55]
1398 #define SWIGTYPE_p_int swig_types[56]
1399 #define SWIGTYPE_p_wxMetaFile swig_types[57]
1400 #define SWIGTYPE_p_unsigned_long swig_types[58]
1401 #define SWIGTYPE_p_wxNativeFontInfo swig_types[59]
1402 #define SWIGTYPE_p_wxEncodingConverter swig_types[60]
1403 #define SWIGTYPE_p_wxColourDatabase swig_types[61]
1404 static swig_type_info *swig_types[63];
1405
1406 /* -------- TYPES TABLE (END) -------- */
1407
1408
1409 /*-----------------------------------------------
1410 @(target):= _gdi_.so
1411 ------------------------------------------------*/
1412 #define SWIG_init init_gdi_
1413
1414 #define SWIG_name "_gdi_"
1415
1416 #include "wx/wxPython/wxPython.h"
1417 #include "wx/wxPython/pyclasses.h"
1418
1419
1420 static const wxString wxPyEmptyString(wxEmptyString);
1421
1422 #include <limits.h>
1423
1424
1425 SWIGINTERN int
1426 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1427 const char *errmsg)
1428 {
1429 if (value < min_value) {
1430 if (errmsg) {
1431 PyErr_Format(PyExc_OverflowError,
1432 "value %ld is less than '%s' minimum %ld",
1433 value, errmsg, min_value);
1434 }
1435 return 0;
1436 } else if (value > max_value) {
1437 if (errmsg) {
1438 PyErr_Format(PyExc_OverflowError,
1439 "value %ld is greater than '%s' maximum %ld",
1440 value, errmsg, max_value);
1441 }
1442 return 0;
1443 }
1444 return 1;
1445 }
1446
1447
1448 SWIGINTERN int
1449 SWIG_AsVal_long(PyObject* obj, long* val)
1450 {
1451 if (PyNumber_Check(obj)) {
1452 if (val) *val = PyInt_AsLong(obj);
1453 return 1;
1454 }
1455 else {
1456 SWIG_type_error("number", obj);
1457 }
1458 return 0;
1459 }
1460
1461
1462 #if INT_MAX != LONG_MAX
1463 SWIGINTERN int
1464 SWIG_AsVal_int(PyObject *obj, int *val)
1465 {
1466 const char* errmsg = val ? "int" : (char*)0;
1467 long v;
1468 if (SWIG_AsVal_long(obj, &v)) {
1469 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1470 if (val) *val = (int)(v);
1471 return 1;
1472 } else {
1473 return 0;
1474 }
1475 } else {
1476 PyErr_Clear();
1477 }
1478 if (val) {
1479 SWIG_type_error(errmsg, obj);
1480 }
1481 return 0;
1482 }
1483 #else
1484 SWIGINTERNSHORT int
1485 SWIG_AsVal_int(PyObject *obj, int *val)
1486 {
1487 return SWIG_AsVal_long(obj,(long*)val);
1488 }
1489 #endif
1490
1491
1492 SWIGINTERN int
1493 SWIG_AsVal_bool(PyObject *obj, bool *val)
1494 {
1495 if (obj == Py_True) {
1496 if (val) *val = true;
1497 return 1;
1498 }
1499 if (obj == Py_False) {
1500 if (val) *val = false;
1501 return 1;
1502 }
1503 int res = 0;
1504 if (SWIG_AsVal_int(obj, &res)) {
1505 if (val) *val = res ? true : false;
1506 return 1;
1507 } else {
1508 PyErr_Clear();
1509 }
1510 if (val) {
1511 SWIG_type_error("bool", obj);
1512 }
1513 return 0;
1514 }
1515
1516
1517 SWIGINTERNSHORT bool
1518 SWIG_As_bool(PyObject* obj)
1519 {
1520 bool v;
1521 if (!SWIG_AsVal_bool(obj, &v)) {
1522 /*
1523 this is needed to make valgrind/purify happier.
1524 */
1525 memset((void*)&v, 0, sizeof(bool));
1526 }
1527 return v;
1528 }
1529
1530
1531 SWIGINTERNSHORT int
1532 SWIG_Check_bool(PyObject* obj)
1533 {
1534 return SWIG_AsVal_bool(obj, (bool*)0);
1535 }
1536
1537
1538 SWIGINTERN int
1539 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1540 {
1541 long v = 0;
1542 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1543 SWIG_type_error("unsigned number", obj);
1544 }
1545 else if (val)
1546 *val = (unsigned long)v;
1547 return 1;
1548 }
1549
1550
1551 SWIGINTERNSHORT int
1552 SWIG_CheckUnsignedLongInRange(unsigned long value,
1553 unsigned long max_value,
1554 const char *errmsg)
1555 {
1556 if (value > max_value) {
1557 if (errmsg) {
1558 PyErr_Format(PyExc_OverflowError,
1559 "value %lu is greater than '%s' minimum %lu",
1560 value, errmsg, max_value);
1561 }
1562 return 0;
1563 }
1564 return 1;
1565 }
1566
1567
1568 SWIGINTERN int
1569 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1570 {
1571 const char* errmsg = val ? "unsigned char" : (char*)0;
1572 unsigned long v;
1573 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1574 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1575 if (val) *val = (unsigned char)(v);
1576 return 1;
1577 } else {
1578 return 0;
1579 }
1580 } else {
1581 PyErr_Clear();
1582 }
1583 if (val) {
1584 SWIG_type_error(errmsg, obj);
1585 }
1586 return 0;
1587 }
1588
1589
1590 SWIGINTERNSHORT unsigned char
1591 SWIG_As_unsigned_SS_char(PyObject* obj)
1592 {
1593 unsigned char v;
1594 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1595 /*
1596 this is needed to make valgrind/purify happier.
1597 */
1598 memset((void*)&v, 0, sizeof(unsigned char));
1599 }
1600 return v;
1601 }
1602
1603
1604 SWIGINTERNSHORT int
1605 SWIG_Check_unsigned_SS_char(PyObject* obj)
1606 {
1607 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1608 }
1609
1610
1611 SWIGINTERNSHORT unsigned long
1612 SWIG_As_unsigned_SS_long(PyObject* obj)
1613 {
1614 unsigned long v;
1615 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1616 /*
1617 this is needed to make valgrind/purify happier.
1618 */
1619 memset((void*)&v, 0, sizeof(unsigned long));
1620 }
1621 return v;
1622 }
1623
1624
1625 SWIGINTERNSHORT int
1626 SWIG_Check_unsigned_SS_long(PyObject* obj)
1627 {
1628 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1629 }
1630
1631
1632 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1633 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1634 /*@@*/
1635
1636
1637 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1638 #define SWIG_From_long PyInt_FromLong
1639 /*@@*/
1640
1641 static PyObject *wxColour_Get(wxColour *self){
1642 PyObject* rv = PyTuple_New(3);
1643 int red = -1;
1644 int green = -1;
1645 int blue = -1;
1646 if (self->Ok()) {
1647 red = self->Red();
1648 green = self->Green();
1649 blue = self->Blue();
1650 }
1651 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1652 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1653 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1654 return rv;
1655 }
1656 static unsigned long wxColour_GetRGB(wxColour *self){
1657 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1658 }
1659
1660 SWIGINTERNSHORT PyObject*
1661 SWIG_From_unsigned_SS_long(unsigned long value)
1662 {
1663 return (value > LONG_MAX) ?
1664 PyLong_FromUnsignedLong(value)
1665 : PyInt_FromLong((long)(value));
1666 }
1667
1668
1669 SWIGINTERNSHORT int
1670 SWIG_As_int(PyObject* obj)
1671 {
1672 int v;
1673 if (!SWIG_AsVal_int(obj, &v)) {
1674 /*
1675 this is needed to make valgrind/purify happier.
1676 */
1677 memset((void*)&v, 0, sizeof(int));
1678 }
1679 return v;
1680 }
1681
1682
1683 SWIGINTERNSHORT int
1684 SWIG_Check_int(PyObject* obj)
1685 {
1686 return SWIG_AsVal_int(obj, (int*)0);
1687 }
1688
1689
1690 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1691 #define SWIG_From_int PyInt_FromLong
1692 /*@@*/
1693
1694
1695 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1696 PyObject* o2;
1697 PyObject* o3;
1698
1699 if (!target) {
1700 target = o;
1701 } else if (target == Py_None) {
1702 Py_DECREF(Py_None);
1703 target = o;
1704 } else {
1705 if (!PyTuple_Check(target)) {
1706 o2 = target;
1707 target = PyTuple_New(1);
1708 PyTuple_SetItem(target, 0, o2);
1709 }
1710 o3 = PyTuple_New(1);
1711 PyTuple_SetItem(o3, 0, o);
1712
1713 o2 = target;
1714 target = PySequence_Concat(o2, o3);
1715 Py_DECREF(o2);
1716 Py_DECREF(o3);
1717 }
1718 return target;
1719 }
1720
1721
1722 static PyObject *wxPen_GetDashes(wxPen *self){
1723 wxDash* dashes;
1724 int count = self->GetDashes(&dashes);
1725 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1726 PyObject* retval = PyList_New(0);
1727 for (int x=0; x<count; x++) {
1728 PyObject* pyint = PyInt_FromLong(dashes[x]);
1729 PyList_Append(retval, pyint);
1730 Py_DECREF(pyint);
1731 }
1732 wxPyEndBlockThreads(blocked);
1733 return retval;
1734 }
1735 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1736 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1737 int size = PyList_Size(pyDashes);
1738 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1739
1740 // black magic warning! The array of wxDashes needs to exist as
1741 // long as the pen does because wxPen does not copy the array. So
1742 // stick a copy in a Python string object and attach it to _self,
1743 // and then call SetDashes with a pointer to that array. Then
1744 // when the Python pen object is destroyed the array will be
1745 // cleaned up too.
1746 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1747 PyObject_SetAttrString(_self, "_dashes", strDashes);
1748
1749 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1750 delete [] dashes;
1751 Py_DECREF(strDashes);
1752 wxPyEndBlockThreads(blocked);
1753 }
1754 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1755 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1756
1757 #include <wx/image.h>
1758
1759 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1760 char** cArray = NULL;
1761 int count;
1762
1763 if (!PyList_Check(listOfStrings)) {
1764 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1765 return NULL;
1766 }
1767 count = PyList_Size(listOfStrings);
1768 cArray = new char*[count];
1769
1770 for(int x=0; x<count; x++) {
1771 // TODO: Need some validation and error checking here
1772 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1773 }
1774 return cArray;
1775 }
1776
1777
1778 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1779 char** cArray = NULL;
1780 wxBitmap* bmp;
1781
1782 cArray = ConvertListOfStrings(listOfStrings);
1783 if (! cArray)
1784 return NULL;
1785 bmp = new wxBitmap(cArray);
1786 delete [] cArray;
1787 return bmp;
1788 }
1789 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1790 char* buf;
1791 int length;
1792 PyString_AsStringAndSize(bits, &buf, &length);
1793 return new wxBitmap(buf, width, height, depth);
1794 }
1795 static wxSize wxBitmap_GetSize(wxBitmap *self){
1796 wxSize size(self->GetWidth(), self->GetHeight());
1797 return size;
1798 }
1799 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1800 wxMask *mask = new wxMask(*self, colour);
1801 self->SetMask(mask);
1802 }
1803 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1804 self->SetWidth(size.x);
1805 self->SetHeight(size.y);
1806 }
1807 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1808 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1809 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1810 if ( !colour.Ok() )
1811 return new wxMask(bitmap, *wxBLACK);
1812 else
1813 return new wxMask(bitmap, colour);
1814 }
1815
1816 #include <wx/iconbndl.h>
1817
1818 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1819 wxIcon* icon = new wxIcon();
1820 icon->CopyFromBitmap(bmp);
1821 return icon;
1822 }
1823 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1824 char** cArray = NULL;
1825 wxIcon* icon;
1826
1827 cArray = ConvertListOfStrings(listOfStrings);
1828 if (! cArray)
1829 return NULL;
1830 icon = new wxIcon(cArray);
1831 delete [] cArray;
1832 return icon;
1833 }
1834 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1835
1836
1837
1838 return new wxIconLocation(*filename);
1839
1840 }
1841 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1842
1843
1844
1845 // do nothing
1846
1847 }
1848 static int wxIconLocation_GetIndex(wxIconLocation *self){
1849
1850
1851
1852 return -1;
1853
1854 }
1855
1856 SWIGINTERNSHORT long
1857 SWIG_As_long(PyObject* obj)
1858 {
1859 long v;
1860 if (!SWIG_AsVal_long(obj, &v)) {
1861 /*
1862 this is needed to make valgrind/purify happier.
1863 */
1864 memset((void*)&v, 0, sizeof(long));
1865 }
1866 return v;
1867 }
1868
1869
1870 SWIGINTERNSHORT int
1871 SWIG_Check_long(PyObject* obj)
1872 {
1873 return SWIG_AsVal_long(obj, (long*)0);
1874 }
1875
1876 static wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1877 #ifdef __WXGTK__
1878 wxImage img(cursorName, type);
1879 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
1880 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
1881 return new wxCursor(img);
1882 #else
1883 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
1884 #endif
1885 }
1886
1887
1888 static void wxRegionIterator_Next(wxRegionIterator *self){
1889 (*self) ++;
1890 }
1891 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1892 return self->operator bool();
1893 }
1894
1895 #include <wx/fontutil.h>
1896 #include <wx/fontmap.h>
1897 #include <wx/fontenum.h>
1898
1899 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1900 return self->ToString();
1901 }
1902
1903 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
1904 static wxNativeEncodingInfo info;
1905 if ( wxGetNativeFontEncoding(encoding, &info) )
1906 return &info;
1907 else
1908 return NULL;
1909 }
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 wxFont *new_wxFont(wxSize const &pixelSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1934 return wxFontBase::New(pixelSize, family, flags, face, encoding);
1935 }
1936 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1937 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1938
1939 class wxPyFontEnumerator : public wxFontEnumerator {
1940 public:
1941 wxPyFontEnumerator() {}
1942 ~wxPyFontEnumerator() {}
1943
1944 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1945 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1946
1947 PYPRIVATE;
1948 };
1949
1950 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
1951 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
1952
1953
1954 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
1955 wxArrayString* arr = self->GetEncodings();
1956 if (arr)
1957 return wxArrayString2PyList_helper(*arr);
1958 else
1959 return PyList_New(0);
1960 }
1961 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
1962 wxArrayString* arr = self->GetFacenames();
1963 if (arr)
1964 return wxArrayString2PyList_helper(*arr);
1965 else
1966 return PyList_New(0);
1967 }
1968
1969 #include <locale.h>
1970
1971 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1972 wxLocale* loc;
1973 if (language == -1)
1974 loc = new wxLocale();
1975 else
1976 loc = new wxLocale(language, flags);
1977 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1978 // for the floating point conversions and such to work right.
1979 #if PY_VERSION_HEX < 0x02040000
1980 setlocale(LC_NUMERIC, "C");
1981 #endif
1982 return loc;
1983 }
1984 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
1985 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
1986 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1987 // for the floating point conversions and such to work right.
1988 #if PY_VERSION_HEX < 0x02040000
1989 setlocale(LC_NUMERIC, "C");
1990 #endif
1991 return rc;
1992 }
1993 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1994 bool rc = self->Init(language, flags);
1995 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1996 // for the floating point conversions and such to work right.
1997 #if PY_VERSION_HEX < 0x02040000
1998 setlocale(LC_NUMERIC, "C");
1999 #endif
2000 return rc;
2001 }
2002
2003 #include "wx/wxPython/pydrawxxx.h"
2004
2005 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2006 wxColour col;
2007 self->GetPixel(x, y, &col);
2008 return col;
2009 }
2010 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2011 wxColour col;
2012 self->GetPixel(pt, &col);
2013 return col;
2014 }
2015
2016 SWIGINTERN int
2017 SWIG_AsVal_double(PyObject *obj, double* val)
2018 {
2019 if (PyNumber_Check(obj)) {
2020 if (val) *val = PyFloat_AsDouble(obj);
2021 return 1;
2022 }
2023 else {
2024 SWIG_type_error("number", obj);
2025 }
2026 return 0;
2027 }
2028
2029
2030 SWIGINTERNSHORT double
2031 SWIG_As_double(PyObject* obj)
2032 {
2033 double v;
2034 if (!SWIG_AsVal_double(obj, &v)) {
2035 /*
2036 this is needed to make valgrind/purify happier.
2037 */
2038 memset((void*)&v, 0, sizeof(double));
2039 }
2040 return v;
2041 }
2042
2043
2044 SWIGINTERNSHORT int
2045 SWIG_Check_double(PyObject* obj)
2046 {
2047 return SWIG_AsVal_double(obj, (double*)0);
2048 }
2049
2050 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2051 wxRect rv;
2052 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2053 return rv;
2054 }
2055
2056 static wxRect wxDC_GetClippingRect(wxDC *self){
2057 wxRect rect;
2058 self->GetClippingBox(rect);
2059 return rect;
2060 }
2061 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2062 wxArrayInt widths;
2063 self->GetPartialTextExtents(text, widths);
2064 return widths;
2065 }
2066
2067 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2068 #define SWIG_From_double PyFloat_FromDouble
2069 /*@@*/
2070
2071
2072 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2073 self->SetLogicalOrigin(point.x, point.y);
2074 }
2075 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2076 self->SetDeviceOrigin(point.x, point.y);
2077 }
2078 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2079 self->CalcBoundingBox(point.x, point.y);
2080 }
2081 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2082 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2083 }
2084 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2085 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2086 }
2087 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2088 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2089 }
2090 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2091 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2092 }
2093 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2094 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2095 }
2096 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2097 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2098 }
2099
2100 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2101 *x1 = dc->MinX();
2102 *y1 = dc->MinY();
2103 *x2 = dc->MaxX();
2104 *y2 = dc->MaxY();
2105 }
2106
2107
2108 #include <wx/dcbuffer.h>
2109
2110
2111 #include <wx/dcps.h>
2112
2113
2114 class wxMetaFile : public wxObject {
2115 public:
2116 wxMetaFile(const wxString&)
2117 { wxPyRaiseNotImplemented(); }
2118 };
2119
2120 class wxMetaFileDC : public wxClientDC {
2121 public:
2122 wxMetaFileDC(const wxString&, int, int, const wxString&)
2123 { wxPyRaiseNotImplemented(); }
2124 };
2125
2126
2127
2128 class wxPrinterDC : public wxClientDC {
2129 public:
2130 wxPrinterDC(const wxPrintData&)
2131 { wxPyRaiseNotImplemented(); }
2132
2133 };
2134
2135
2136
2137 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2138 self->AddColour(name, wxColour(red, green, blue));
2139 }
2140
2141 #include <wx/effects.h>
2142
2143 #ifdef __cplusplus
2144 extern "C" {
2145 #endif
2146 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2147 PyObject *resultobj;
2148 wxGDIObject *result;
2149 char *kwnames[] = {
2150 NULL
2151 };
2152
2153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2154 {
2155 if (!wxPyCheckForApp()) SWIG_fail;
2156 PyThreadState* __tstate = wxPyBeginAllowThreads();
2157 result = (wxGDIObject *)new wxGDIObject();
2158
2159 wxPyEndAllowThreads(__tstate);
2160 if (PyErr_Occurred()) SWIG_fail;
2161 }
2162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2163 return resultobj;
2164 fail:
2165 return NULL;
2166 }
2167
2168
2169 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2170 PyObject *resultobj;
2171 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2172 PyObject * obj0 = 0 ;
2173 char *kwnames[] = {
2174 (char *) "self", NULL
2175 };
2176
2177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2179 if (SWIG_arg_fail(1)) SWIG_fail;
2180 {
2181 PyThreadState* __tstate = wxPyBeginAllowThreads();
2182 delete arg1;
2183
2184 wxPyEndAllowThreads(__tstate);
2185 if (PyErr_Occurred()) SWIG_fail;
2186 }
2187 Py_INCREF(Py_None); resultobj = Py_None;
2188 return resultobj;
2189 fail:
2190 return NULL;
2191 }
2192
2193
2194 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2195 PyObject *resultobj;
2196 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2197 bool result;
2198 PyObject * obj0 = 0 ;
2199 char *kwnames[] = {
2200 (char *) "self", NULL
2201 };
2202
2203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2205 if (SWIG_arg_fail(1)) SWIG_fail;
2206 {
2207 PyThreadState* __tstate = wxPyBeginAllowThreads();
2208 result = (bool)(arg1)->GetVisible();
2209
2210 wxPyEndAllowThreads(__tstate);
2211 if (PyErr_Occurred()) SWIG_fail;
2212 }
2213 {
2214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2215 }
2216 return resultobj;
2217 fail:
2218 return NULL;
2219 }
2220
2221
2222 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2223 PyObject *resultobj;
2224 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2225 bool arg2 ;
2226 PyObject * obj0 = 0 ;
2227 PyObject * obj1 = 0 ;
2228 char *kwnames[] = {
2229 (char *) "self",(char *) "visible", NULL
2230 };
2231
2232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2234 if (SWIG_arg_fail(1)) SWIG_fail;
2235 {
2236 arg2 = (bool)(SWIG_As_bool(obj1));
2237 if (SWIG_arg_fail(2)) SWIG_fail;
2238 }
2239 {
2240 PyThreadState* __tstate = wxPyBeginAllowThreads();
2241 (arg1)->SetVisible(arg2);
2242
2243 wxPyEndAllowThreads(__tstate);
2244 if (PyErr_Occurred()) SWIG_fail;
2245 }
2246 Py_INCREF(Py_None); resultobj = Py_None;
2247 return resultobj;
2248 fail:
2249 return NULL;
2250 }
2251
2252
2253 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2254 PyObject *resultobj;
2255 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2256 bool result;
2257 PyObject * obj0 = 0 ;
2258 char *kwnames[] = {
2259 (char *) "self", NULL
2260 };
2261
2262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2264 if (SWIG_arg_fail(1)) SWIG_fail;
2265 {
2266 PyThreadState* __tstate = wxPyBeginAllowThreads();
2267 result = (bool)(arg1)->IsNull();
2268
2269 wxPyEndAllowThreads(__tstate);
2270 if (PyErr_Occurred()) SWIG_fail;
2271 }
2272 {
2273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2274 }
2275 return resultobj;
2276 fail:
2277 return NULL;
2278 }
2279
2280
2281 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2282 PyObject *obj;
2283 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2284 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2285 Py_INCREF(obj);
2286 return Py_BuildValue((char *)"");
2287 }
2288 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2289 PyObject *resultobj;
2290 byte arg1 = (byte) 0 ;
2291 byte arg2 = (byte) 0 ;
2292 byte arg3 = (byte) 0 ;
2293 wxColour *result;
2294 PyObject * obj0 = 0 ;
2295 PyObject * obj1 = 0 ;
2296 PyObject * obj2 = 0 ;
2297 char *kwnames[] = {
2298 (char *) "red",(char *) "green",(char *) "blue", NULL
2299 };
2300
2301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2302 if (obj0) {
2303 {
2304 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2305 if (SWIG_arg_fail(1)) SWIG_fail;
2306 }
2307 }
2308 if (obj1) {
2309 {
2310 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2311 if (SWIG_arg_fail(2)) SWIG_fail;
2312 }
2313 }
2314 if (obj2) {
2315 {
2316 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2317 if (SWIG_arg_fail(3)) SWIG_fail;
2318 }
2319 }
2320 {
2321 PyThreadState* __tstate = wxPyBeginAllowThreads();
2322 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2323
2324 wxPyEndAllowThreads(__tstate);
2325 if (PyErr_Occurred()) SWIG_fail;
2326 }
2327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2328 return resultobj;
2329 fail:
2330 return NULL;
2331 }
2332
2333
2334 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2335 PyObject *resultobj;
2336 wxString *arg1 = 0 ;
2337 wxColour *result;
2338 bool temp1 = false ;
2339 PyObject * obj0 = 0 ;
2340 char *kwnames[] = {
2341 (char *) "colorName", NULL
2342 };
2343
2344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2345 {
2346 arg1 = wxString_in_helper(obj0);
2347 if (arg1 == NULL) SWIG_fail;
2348 temp1 = true;
2349 }
2350 {
2351 if (!wxPyCheckForApp()) SWIG_fail;
2352 PyThreadState* __tstate = wxPyBeginAllowThreads();
2353 result = (wxColour *)new wxColour((wxString const &)*arg1);
2354
2355 wxPyEndAllowThreads(__tstate);
2356 if (PyErr_Occurred()) SWIG_fail;
2357 }
2358 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2359 {
2360 if (temp1)
2361 delete arg1;
2362 }
2363 return resultobj;
2364 fail:
2365 {
2366 if (temp1)
2367 delete arg1;
2368 }
2369 return NULL;
2370 }
2371
2372
2373 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2374 PyObject *resultobj;
2375 unsigned long arg1 ;
2376 wxColour *result;
2377 PyObject * obj0 = 0 ;
2378 char *kwnames[] = {
2379 (char *) "colRGB", NULL
2380 };
2381
2382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2383 {
2384 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2385 if (SWIG_arg_fail(1)) SWIG_fail;
2386 }
2387 {
2388 PyThreadState* __tstate = wxPyBeginAllowThreads();
2389 result = (wxColour *)new wxColour(arg1);
2390
2391 wxPyEndAllowThreads(__tstate);
2392 if (PyErr_Occurred()) SWIG_fail;
2393 }
2394 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2395 return resultobj;
2396 fail:
2397 return NULL;
2398 }
2399
2400
2401 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2402 PyObject *resultobj;
2403 wxColour *arg1 = (wxColour *) 0 ;
2404 PyObject * obj0 = 0 ;
2405 char *kwnames[] = {
2406 (char *) "self", NULL
2407 };
2408
2409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2411 if (SWIG_arg_fail(1)) SWIG_fail;
2412 {
2413 PyThreadState* __tstate = wxPyBeginAllowThreads();
2414 delete arg1;
2415
2416 wxPyEndAllowThreads(__tstate);
2417 if (PyErr_Occurred()) SWIG_fail;
2418 }
2419 Py_INCREF(Py_None); resultobj = Py_None;
2420 return resultobj;
2421 fail:
2422 return NULL;
2423 }
2424
2425
2426 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2427 PyObject *resultobj;
2428 wxColour *arg1 = (wxColour *) 0 ;
2429 byte result;
2430 PyObject * obj0 = 0 ;
2431 char *kwnames[] = {
2432 (char *) "self", NULL
2433 };
2434
2435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2437 if (SWIG_arg_fail(1)) SWIG_fail;
2438 {
2439 PyThreadState* __tstate = wxPyBeginAllowThreads();
2440 result = (byte)(arg1)->Red();
2441
2442 wxPyEndAllowThreads(__tstate);
2443 if (PyErr_Occurred()) SWIG_fail;
2444 }
2445 {
2446 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2447 }
2448 return resultobj;
2449 fail:
2450 return NULL;
2451 }
2452
2453
2454 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2455 PyObject *resultobj;
2456 wxColour *arg1 = (wxColour *) 0 ;
2457 byte result;
2458 PyObject * obj0 = 0 ;
2459 char *kwnames[] = {
2460 (char *) "self", NULL
2461 };
2462
2463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2465 if (SWIG_arg_fail(1)) SWIG_fail;
2466 {
2467 PyThreadState* __tstate = wxPyBeginAllowThreads();
2468 result = (byte)(arg1)->Green();
2469
2470 wxPyEndAllowThreads(__tstate);
2471 if (PyErr_Occurred()) SWIG_fail;
2472 }
2473 {
2474 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2475 }
2476 return resultobj;
2477 fail:
2478 return NULL;
2479 }
2480
2481
2482 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2483 PyObject *resultobj;
2484 wxColour *arg1 = (wxColour *) 0 ;
2485 byte result;
2486 PyObject * obj0 = 0 ;
2487 char *kwnames[] = {
2488 (char *) "self", NULL
2489 };
2490
2491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2493 if (SWIG_arg_fail(1)) SWIG_fail;
2494 {
2495 PyThreadState* __tstate = wxPyBeginAllowThreads();
2496 result = (byte)(arg1)->Blue();
2497
2498 wxPyEndAllowThreads(__tstate);
2499 if (PyErr_Occurred()) SWIG_fail;
2500 }
2501 {
2502 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2503 }
2504 return resultobj;
2505 fail:
2506 return NULL;
2507 }
2508
2509
2510 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2511 PyObject *resultobj;
2512 wxColour *arg1 = (wxColour *) 0 ;
2513 bool result;
2514 PyObject * obj0 = 0 ;
2515 char *kwnames[] = {
2516 (char *) "self", NULL
2517 };
2518
2519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2521 if (SWIG_arg_fail(1)) SWIG_fail;
2522 {
2523 PyThreadState* __tstate = wxPyBeginAllowThreads();
2524 result = (bool)(arg1)->Ok();
2525
2526 wxPyEndAllowThreads(__tstate);
2527 if (PyErr_Occurred()) SWIG_fail;
2528 }
2529 {
2530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2531 }
2532 return resultobj;
2533 fail:
2534 return NULL;
2535 }
2536
2537
2538 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2539 PyObject *resultobj;
2540 wxColour *arg1 = (wxColour *) 0 ;
2541 byte arg2 ;
2542 byte arg3 ;
2543 byte arg4 ;
2544 PyObject * obj0 = 0 ;
2545 PyObject * obj1 = 0 ;
2546 PyObject * obj2 = 0 ;
2547 PyObject * obj3 = 0 ;
2548 char *kwnames[] = {
2549 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2550 };
2551
2552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2554 if (SWIG_arg_fail(1)) SWIG_fail;
2555 {
2556 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2557 if (SWIG_arg_fail(2)) SWIG_fail;
2558 }
2559 {
2560 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2561 if (SWIG_arg_fail(3)) SWIG_fail;
2562 }
2563 {
2564 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2565 if (SWIG_arg_fail(4)) SWIG_fail;
2566 }
2567 {
2568 PyThreadState* __tstate = wxPyBeginAllowThreads();
2569 (arg1)->Set(arg2,arg3,arg4);
2570
2571 wxPyEndAllowThreads(__tstate);
2572 if (PyErr_Occurred()) SWIG_fail;
2573 }
2574 Py_INCREF(Py_None); resultobj = Py_None;
2575 return resultobj;
2576 fail:
2577 return NULL;
2578 }
2579
2580
2581 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2582 PyObject *resultobj;
2583 wxColour *arg1 = (wxColour *) 0 ;
2584 unsigned long arg2 ;
2585 PyObject * obj0 = 0 ;
2586 PyObject * obj1 = 0 ;
2587 char *kwnames[] = {
2588 (char *) "self",(char *) "colRGB", NULL
2589 };
2590
2591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2593 if (SWIG_arg_fail(1)) SWIG_fail;
2594 {
2595 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2596 if (SWIG_arg_fail(2)) SWIG_fail;
2597 }
2598 {
2599 PyThreadState* __tstate = wxPyBeginAllowThreads();
2600 (arg1)->Set(arg2);
2601
2602 wxPyEndAllowThreads(__tstate);
2603 if (PyErr_Occurred()) SWIG_fail;
2604 }
2605 Py_INCREF(Py_None); resultobj = Py_None;
2606 return resultobj;
2607 fail:
2608 return NULL;
2609 }
2610
2611
2612 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2613 PyObject *resultobj;
2614 wxColour *arg1 = (wxColour *) 0 ;
2615 wxString *arg2 = 0 ;
2616 bool temp2 = false ;
2617 PyObject * obj0 = 0 ;
2618 PyObject * obj1 = 0 ;
2619 char *kwnames[] = {
2620 (char *) "self",(char *) "colourName", NULL
2621 };
2622
2623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2625 if (SWIG_arg_fail(1)) SWIG_fail;
2626 {
2627 arg2 = wxString_in_helper(obj1);
2628 if (arg2 == NULL) SWIG_fail;
2629 temp2 = true;
2630 }
2631 {
2632 PyThreadState* __tstate = wxPyBeginAllowThreads();
2633 (arg1)->InitFromName((wxString const &)*arg2);
2634
2635 wxPyEndAllowThreads(__tstate);
2636 if (PyErr_Occurred()) SWIG_fail;
2637 }
2638 Py_INCREF(Py_None); resultobj = Py_None;
2639 {
2640 if (temp2)
2641 delete arg2;
2642 }
2643 return resultobj;
2644 fail:
2645 {
2646 if (temp2)
2647 delete arg2;
2648 }
2649 return NULL;
2650 }
2651
2652
2653 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2654 PyObject *resultobj;
2655 wxColour *arg1 = (wxColour *) 0 ;
2656 long result;
2657 PyObject * obj0 = 0 ;
2658 char *kwnames[] = {
2659 (char *) "self", NULL
2660 };
2661
2662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2664 if (SWIG_arg_fail(1)) SWIG_fail;
2665 {
2666 PyThreadState* __tstate = wxPyBeginAllowThreads();
2667 result = (long)((wxColour const *)arg1)->GetPixel();
2668
2669 wxPyEndAllowThreads(__tstate);
2670 if (PyErr_Occurred()) SWIG_fail;
2671 }
2672 {
2673 resultobj = SWIG_From_long((long)(result));
2674 }
2675 return resultobj;
2676 fail:
2677 return NULL;
2678 }
2679
2680
2681 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2682 PyObject *resultobj;
2683 wxColour *arg1 = (wxColour *) 0 ;
2684 wxColour *arg2 = 0 ;
2685 bool result;
2686 wxColour temp2 ;
2687 PyObject * obj0 = 0 ;
2688 PyObject * obj1 = 0 ;
2689 char *kwnames[] = {
2690 (char *) "self",(char *) "colour", NULL
2691 };
2692
2693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2695 if (SWIG_arg_fail(1)) SWIG_fail;
2696 {
2697 arg2 = &temp2;
2698 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2699 }
2700 {
2701 PyThreadState* __tstate = wxPyBeginAllowThreads();
2702 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2703
2704 wxPyEndAllowThreads(__tstate);
2705 if (PyErr_Occurred()) SWIG_fail;
2706 }
2707 {
2708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2709 }
2710 return resultobj;
2711 fail:
2712 return NULL;
2713 }
2714
2715
2716 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2717 PyObject *resultobj;
2718 wxColour *arg1 = (wxColour *) 0 ;
2719 wxColour *arg2 = 0 ;
2720 bool result;
2721 wxColour temp2 ;
2722 PyObject * obj0 = 0 ;
2723 PyObject * obj1 = 0 ;
2724 char *kwnames[] = {
2725 (char *) "self",(char *) "colour", NULL
2726 };
2727
2728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2730 if (SWIG_arg_fail(1)) SWIG_fail;
2731 {
2732 arg2 = &temp2;
2733 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2734 }
2735 {
2736 PyThreadState* __tstate = wxPyBeginAllowThreads();
2737 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2738
2739 wxPyEndAllowThreads(__tstate);
2740 if (PyErr_Occurred()) SWIG_fail;
2741 }
2742 {
2743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2744 }
2745 return resultobj;
2746 fail:
2747 return NULL;
2748 }
2749
2750
2751 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2752 PyObject *resultobj;
2753 wxColour *arg1 = (wxColour *) 0 ;
2754 PyObject *result;
2755 PyObject * obj0 = 0 ;
2756 char *kwnames[] = {
2757 (char *) "self", NULL
2758 };
2759
2760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2762 if (SWIG_arg_fail(1)) SWIG_fail;
2763 {
2764 PyThreadState* __tstate = wxPyBeginAllowThreads();
2765 result = (PyObject *)wxColour_Get(arg1);
2766
2767 wxPyEndAllowThreads(__tstate);
2768 if (PyErr_Occurred()) SWIG_fail;
2769 }
2770 resultobj = result;
2771 return resultobj;
2772 fail:
2773 return NULL;
2774 }
2775
2776
2777 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2778 PyObject *resultobj;
2779 wxColour *arg1 = (wxColour *) 0 ;
2780 unsigned long result;
2781 PyObject * obj0 = 0 ;
2782 char *kwnames[] = {
2783 (char *) "self", NULL
2784 };
2785
2786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2788 if (SWIG_arg_fail(1)) SWIG_fail;
2789 {
2790 PyThreadState* __tstate = wxPyBeginAllowThreads();
2791 result = (unsigned long)wxColour_GetRGB(arg1);
2792
2793 wxPyEndAllowThreads(__tstate);
2794 if (PyErr_Occurred()) SWIG_fail;
2795 }
2796 {
2797 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2798 }
2799 return resultobj;
2800 fail:
2801 return NULL;
2802 }
2803
2804
2805 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2806 PyObject *obj;
2807 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2808 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2809 Py_INCREF(obj);
2810 return Py_BuildValue((char *)"");
2811 }
2812 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2813 PyObject *resultobj;
2814 int arg1 ;
2815 unsigned char *arg2 = (unsigned char *) 0 ;
2816 unsigned char *arg3 = (unsigned char *) 0 ;
2817 unsigned char *arg4 = (unsigned char *) 0 ;
2818 wxPalette *result;
2819 PyObject * obj0 = 0 ;
2820 PyObject * obj1 = 0 ;
2821 PyObject * obj2 = 0 ;
2822 PyObject * obj3 = 0 ;
2823 char *kwnames[] = {
2824 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2825 };
2826
2827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2828 {
2829 arg1 = (int)(SWIG_As_int(obj0));
2830 if (SWIG_arg_fail(1)) SWIG_fail;
2831 }
2832 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2833 if (SWIG_arg_fail(2)) SWIG_fail;
2834 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2835 if (SWIG_arg_fail(3)) SWIG_fail;
2836 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2837 if (SWIG_arg_fail(4)) SWIG_fail;
2838 {
2839 if (!wxPyCheckForApp()) SWIG_fail;
2840 PyThreadState* __tstate = wxPyBeginAllowThreads();
2841 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2842
2843 wxPyEndAllowThreads(__tstate);
2844 if (PyErr_Occurred()) SWIG_fail;
2845 }
2846 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2847 return resultobj;
2848 fail:
2849 return NULL;
2850 }
2851
2852
2853 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2854 PyObject *resultobj;
2855 wxPalette *arg1 = (wxPalette *) 0 ;
2856 PyObject * obj0 = 0 ;
2857 char *kwnames[] = {
2858 (char *) "self", NULL
2859 };
2860
2861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2863 if (SWIG_arg_fail(1)) SWIG_fail;
2864 {
2865 PyThreadState* __tstate = wxPyBeginAllowThreads();
2866 delete arg1;
2867
2868 wxPyEndAllowThreads(__tstate);
2869 if (PyErr_Occurred()) SWIG_fail;
2870 }
2871 Py_INCREF(Py_None); resultobj = Py_None;
2872 return resultobj;
2873 fail:
2874 return NULL;
2875 }
2876
2877
2878 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2879 PyObject *resultobj;
2880 wxPalette *arg1 = (wxPalette *) 0 ;
2881 byte arg2 ;
2882 byte arg3 ;
2883 byte arg4 ;
2884 int result;
2885 PyObject * obj0 = 0 ;
2886 PyObject * obj1 = 0 ;
2887 PyObject * obj2 = 0 ;
2888 PyObject * obj3 = 0 ;
2889 char *kwnames[] = {
2890 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2891 };
2892
2893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2895 if (SWIG_arg_fail(1)) SWIG_fail;
2896 {
2897 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2898 if (SWIG_arg_fail(2)) SWIG_fail;
2899 }
2900 {
2901 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2902 if (SWIG_arg_fail(3)) SWIG_fail;
2903 }
2904 {
2905 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2906 if (SWIG_arg_fail(4)) SWIG_fail;
2907 }
2908 {
2909 PyThreadState* __tstate = wxPyBeginAllowThreads();
2910 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2911
2912 wxPyEndAllowThreads(__tstate);
2913 if (PyErr_Occurred()) SWIG_fail;
2914 }
2915 {
2916 resultobj = SWIG_From_int((int)(result));
2917 }
2918 return resultobj;
2919 fail:
2920 return NULL;
2921 }
2922
2923
2924 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2925 PyObject *resultobj;
2926 wxPalette *arg1 = (wxPalette *) 0 ;
2927 int arg2 ;
2928 byte *arg3 = (byte *) 0 ;
2929 byte *arg4 = (byte *) 0 ;
2930 byte *arg5 = (byte *) 0 ;
2931 bool result;
2932 byte temp3 ;
2933 int res3 = 0 ;
2934 byte temp4 ;
2935 int res4 = 0 ;
2936 byte temp5 ;
2937 int res5 = 0 ;
2938 PyObject * obj0 = 0 ;
2939 PyObject * obj1 = 0 ;
2940 char *kwnames[] = {
2941 (char *) "self",(char *) "pixel", NULL
2942 };
2943
2944 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2945 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2946 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2949 if (SWIG_arg_fail(1)) SWIG_fail;
2950 {
2951 arg2 = (int)(SWIG_As_int(obj1));
2952 if (SWIG_arg_fail(2)) SWIG_fail;
2953 }
2954 {
2955 PyThreadState* __tstate = wxPyBeginAllowThreads();
2956 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2957
2958 wxPyEndAllowThreads(__tstate);
2959 if (PyErr_Occurred()) SWIG_fail;
2960 }
2961 {
2962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2963 }
2964 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2965 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2966 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2967 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2968 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2969 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2970 return resultobj;
2971 fail:
2972 return NULL;
2973 }
2974
2975
2976 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
2977 PyObject *resultobj;
2978 wxPalette *arg1 = (wxPalette *) 0 ;
2979 int result;
2980 PyObject * obj0 = 0 ;
2981 char *kwnames[] = {
2982 (char *) "self", NULL
2983 };
2984
2985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
2986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2987 if (SWIG_arg_fail(1)) SWIG_fail;
2988 {
2989 PyThreadState* __tstate = wxPyBeginAllowThreads();
2990 result = (int)((wxPalette const *)arg1)->GetColoursCount();
2991
2992 wxPyEndAllowThreads(__tstate);
2993 if (PyErr_Occurred()) SWIG_fail;
2994 }
2995 {
2996 resultobj = SWIG_From_int((int)(result));
2997 }
2998 return resultobj;
2999 fail:
3000 return NULL;
3001 }
3002
3003
3004 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3005 PyObject *resultobj;
3006 wxPalette *arg1 = (wxPalette *) 0 ;
3007 bool result;
3008 PyObject * obj0 = 0 ;
3009 char *kwnames[] = {
3010 (char *) "self", NULL
3011 };
3012
3013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
3014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3015 if (SWIG_arg_fail(1)) SWIG_fail;
3016 {
3017 PyThreadState* __tstate = wxPyBeginAllowThreads();
3018 result = (bool)(arg1)->Ok();
3019
3020 wxPyEndAllowThreads(__tstate);
3021 if (PyErr_Occurred()) SWIG_fail;
3022 }
3023 {
3024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3025 }
3026 return resultobj;
3027 fail:
3028 return NULL;
3029 }
3030
3031
3032 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3033 PyObject *obj;
3034 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3035 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3036 Py_INCREF(obj);
3037 return Py_BuildValue((char *)"");
3038 }
3039 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3040 PyObject *resultobj;
3041 wxColour *arg1 = 0 ;
3042 int arg2 = (int) 1 ;
3043 int arg3 = (int) wxSOLID ;
3044 wxPen *result;
3045 wxColour temp1 ;
3046 PyObject * obj0 = 0 ;
3047 PyObject * obj1 = 0 ;
3048 PyObject * obj2 = 0 ;
3049 char *kwnames[] = {
3050 (char *) "colour",(char *) "width",(char *) "style", NULL
3051 };
3052
3053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3054 {
3055 arg1 = &temp1;
3056 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3057 }
3058 if (obj1) {
3059 {
3060 arg2 = (int)(SWIG_As_int(obj1));
3061 if (SWIG_arg_fail(2)) SWIG_fail;
3062 }
3063 }
3064 if (obj2) {
3065 {
3066 arg3 = (int)(SWIG_As_int(obj2));
3067 if (SWIG_arg_fail(3)) SWIG_fail;
3068 }
3069 }
3070 {
3071 if (!wxPyCheckForApp()) SWIG_fail;
3072 PyThreadState* __tstate = wxPyBeginAllowThreads();
3073 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3074
3075 wxPyEndAllowThreads(__tstate);
3076 if (PyErr_Occurred()) SWIG_fail;
3077 }
3078 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3079 return resultobj;
3080 fail:
3081 return NULL;
3082 }
3083
3084
3085 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3086 PyObject *resultobj;
3087 wxPen *arg1 = (wxPen *) 0 ;
3088 PyObject * obj0 = 0 ;
3089 char *kwnames[] = {
3090 (char *) "self", NULL
3091 };
3092
3093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3095 if (SWIG_arg_fail(1)) SWIG_fail;
3096 {
3097 PyThreadState* __tstate = wxPyBeginAllowThreads();
3098 delete arg1;
3099
3100 wxPyEndAllowThreads(__tstate);
3101 if (PyErr_Occurred()) SWIG_fail;
3102 }
3103 Py_INCREF(Py_None); resultobj = Py_None;
3104 return resultobj;
3105 fail:
3106 return NULL;
3107 }
3108
3109
3110 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3111 PyObject *resultobj;
3112 wxPen *arg1 = (wxPen *) 0 ;
3113 int result;
3114 PyObject * obj0 = 0 ;
3115 char *kwnames[] = {
3116 (char *) "self", NULL
3117 };
3118
3119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3121 if (SWIG_arg_fail(1)) SWIG_fail;
3122 {
3123 PyThreadState* __tstate = wxPyBeginAllowThreads();
3124 result = (int)(arg1)->GetCap();
3125
3126 wxPyEndAllowThreads(__tstate);
3127 if (PyErr_Occurred()) SWIG_fail;
3128 }
3129 {
3130 resultobj = SWIG_From_int((int)(result));
3131 }
3132 return resultobj;
3133 fail:
3134 return NULL;
3135 }
3136
3137
3138 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3139 PyObject *resultobj;
3140 wxPen *arg1 = (wxPen *) 0 ;
3141 wxColour result;
3142 PyObject * obj0 = 0 ;
3143 char *kwnames[] = {
3144 (char *) "self", NULL
3145 };
3146
3147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3149 if (SWIG_arg_fail(1)) SWIG_fail;
3150 {
3151 PyThreadState* __tstate = wxPyBeginAllowThreads();
3152 result = (arg1)->GetColour();
3153
3154 wxPyEndAllowThreads(__tstate);
3155 if (PyErr_Occurred()) SWIG_fail;
3156 }
3157 {
3158 wxColour * resultptr;
3159 resultptr = new wxColour((wxColour &)(result));
3160 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3161 }
3162 return resultobj;
3163 fail:
3164 return NULL;
3165 }
3166
3167
3168 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3169 PyObject *resultobj;
3170 wxPen *arg1 = (wxPen *) 0 ;
3171 int result;
3172 PyObject * obj0 = 0 ;
3173 char *kwnames[] = {
3174 (char *) "self", NULL
3175 };
3176
3177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3179 if (SWIG_arg_fail(1)) SWIG_fail;
3180 {
3181 PyThreadState* __tstate = wxPyBeginAllowThreads();
3182 result = (int)(arg1)->GetJoin();
3183
3184 wxPyEndAllowThreads(__tstate);
3185 if (PyErr_Occurred()) SWIG_fail;
3186 }
3187 {
3188 resultobj = SWIG_From_int((int)(result));
3189 }
3190 return resultobj;
3191 fail:
3192 return NULL;
3193 }
3194
3195
3196 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3197 PyObject *resultobj;
3198 wxPen *arg1 = (wxPen *) 0 ;
3199 int result;
3200 PyObject * obj0 = 0 ;
3201 char *kwnames[] = {
3202 (char *) "self", NULL
3203 };
3204
3205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3207 if (SWIG_arg_fail(1)) SWIG_fail;
3208 {
3209 PyThreadState* __tstate = wxPyBeginAllowThreads();
3210 result = (int)(arg1)->GetStyle();
3211
3212 wxPyEndAllowThreads(__tstate);
3213 if (PyErr_Occurred()) SWIG_fail;
3214 }
3215 {
3216 resultobj = SWIG_From_int((int)(result));
3217 }
3218 return resultobj;
3219 fail:
3220 return NULL;
3221 }
3222
3223
3224 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3225 PyObject *resultobj;
3226 wxPen *arg1 = (wxPen *) 0 ;
3227 int result;
3228 PyObject * obj0 = 0 ;
3229 char *kwnames[] = {
3230 (char *) "self", NULL
3231 };
3232
3233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3235 if (SWIG_arg_fail(1)) SWIG_fail;
3236 {
3237 PyThreadState* __tstate = wxPyBeginAllowThreads();
3238 result = (int)(arg1)->GetWidth();
3239
3240 wxPyEndAllowThreads(__tstate);
3241 if (PyErr_Occurred()) SWIG_fail;
3242 }
3243 {
3244 resultobj = SWIG_From_int((int)(result));
3245 }
3246 return resultobj;
3247 fail:
3248 return NULL;
3249 }
3250
3251
3252 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3253 PyObject *resultobj;
3254 wxPen *arg1 = (wxPen *) 0 ;
3255 bool result;
3256 PyObject * obj0 = 0 ;
3257 char *kwnames[] = {
3258 (char *) "self", NULL
3259 };
3260
3261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3263 if (SWIG_arg_fail(1)) SWIG_fail;
3264 {
3265 PyThreadState* __tstate = wxPyBeginAllowThreads();
3266 result = (bool)(arg1)->Ok();
3267
3268 wxPyEndAllowThreads(__tstate);
3269 if (PyErr_Occurred()) SWIG_fail;
3270 }
3271 {
3272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3273 }
3274 return resultobj;
3275 fail:
3276 return NULL;
3277 }
3278
3279
3280 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3281 PyObject *resultobj;
3282 wxPen *arg1 = (wxPen *) 0 ;
3283 int arg2 ;
3284 PyObject * obj0 = 0 ;
3285 PyObject * obj1 = 0 ;
3286 char *kwnames[] = {
3287 (char *) "self",(char *) "cap_style", NULL
3288 };
3289
3290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3292 if (SWIG_arg_fail(1)) SWIG_fail;
3293 {
3294 arg2 = (int)(SWIG_As_int(obj1));
3295 if (SWIG_arg_fail(2)) SWIG_fail;
3296 }
3297 {
3298 PyThreadState* __tstate = wxPyBeginAllowThreads();
3299 (arg1)->SetCap(arg2);
3300
3301 wxPyEndAllowThreads(__tstate);
3302 if (PyErr_Occurred()) SWIG_fail;
3303 }
3304 Py_INCREF(Py_None); resultobj = Py_None;
3305 return resultobj;
3306 fail:
3307 return NULL;
3308 }
3309
3310
3311 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3312 PyObject *resultobj;
3313 wxPen *arg1 = (wxPen *) 0 ;
3314 wxColour *arg2 = 0 ;
3315 wxColour temp2 ;
3316 PyObject * obj0 = 0 ;
3317 PyObject * obj1 = 0 ;
3318 char *kwnames[] = {
3319 (char *) "self",(char *) "colour", NULL
3320 };
3321
3322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3324 if (SWIG_arg_fail(1)) SWIG_fail;
3325 {
3326 arg2 = &temp2;
3327 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3328 }
3329 {
3330 PyThreadState* __tstate = wxPyBeginAllowThreads();
3331 (arg1)->SetColour(*arg2);
3332
3333 wxPyEndAllowThreads(__tstate);
3334 if (PyErr_Occurred()) SWIG_fail;
3335 }
3336 Py_INCREF(Py_None); resultobj = Py_None;
3337 return resultobj;
3338 fail:
3339 return NULL;
3340 }
3341
3342
3343 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3344 PyObject *resultobj;
3345 wxPen *arg1 = (wxPen *) 0 ;
3346 int arg2 ;
3347 PyObject * obj0 = 0 ;
3348 PyObject * obj1 = 0 ;
3349 char *kwnames[] = {
3350 (char *) "self",(char *) "join_style", NULL
3351 };
3352
3353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3355 if (SWIG_arg_fail(1)) SWIG_fail;
3356 {
3357 arg2 = (int)(SWIG_As_int(obj1));
3358 if (SWIG_arg_fail(2)) SWIG_fail;
3359 }
3360 {
3361 PyThreadState* __tstate = wxPyBeginAllowThreads();
3362 (arg1)->SetJoin(arg2);
3363
3364 wxPyEndAllowThreads(__tstate);
3365 if (PyErr_Occurred()) SWIG_fail;
3366 }
3367 Py_INCREF(Py_None); resultobj = Py_None;
3368 return resultobj;
3369 fail:
3370 return NULL;
3371 }
3372
3373
3374 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3375 PyObject *resultobj;
3376 wxPen *arg1 = (wxPen *) 0 ;
3377 int arg2 ;
3378 PyObject * obj0 = 0 ;
3379 PyObject * obj1 = 0 ;
3380 char *kwnames[] = {
3381 (char *) "self",(char *) "style", NULL
3382 };
3383
3384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3386 if (SWIG_arg_fail(1)) SWIG_fail;
3387 {
3388 arg2 = (int)(SWIG_As_int(obj1));
3389 if (SWIG_arg_fail(2)) SWIG_fail;
3390 }
3391 {
3392 PyThreadState* __tstate = wxPyBeginAllowThreads();
3393 (arg1)->SetStyle(arg2);
3394
3395 wxPyEndAllowThreads(__tstate);
3396 if (PyErr_Occurred()) SWIG_fail;
3397 }
3398 Py_INCREF(Py_None); resultobj = Py_None;
3399 return resultobj;
3400 fail:
3401 return NULL;
3402 }
3403
3404
3405 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3406 PyObject *resultobj;
3407 wxPen *arg1 = (wxPen *) 0 ;
3408 int arg2 ;
3409 PyObject * obj0 = 0 ;
3410 PyObject * obj1 = 0 ;
3411 char *kwnames[] = {
3412 (char *) "self",(char *) "width", NULL
3413 };
3414
3415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3417 if (SWIG_arg_fail(1)) SWIG_fail;
3418 {
3419 arg2 = (int)(SWIG_As_int(obj1));
3420 if (SWIG_arg_fail(2)) SWIG_fail;
3421 }
3422 {
3423 PyThreadState* __tstate = wxPyBeginAllowThreads();
3424 (arg1)->SetWidth(arg2);
3425
3426 wxPyEndAllowThreads(__tstate);
3427 if (PyErr_Occurred()) SWIG_fail;
3428 }
3429 Py_INCREF(Py_None); resultobj = Py_None;
3430 return resultobj;
3431 fail:
3432 return NULL;
3433 }
3434
3435
3436 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3437 PyObject *resultobj;
3438 wxPen *arg1 = (wxPen *) 0 ;
3439 int arg2 ;
3440 wxDash *arg3 = (wxDash *) 0 ;
3441 PyObject * obj0 = 0 ;
3442 PyObject * obj1 = 0 ;
3443 char *kwnames[] = {
3444 (char *) "self",(char *) "dashes", NULL
3445 };
3446
3447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3449 if (SWIG_arg_fail(1)) SWIG_fail;
3450 {
3451 arg2 = PyList_Size(obj1);
3452 arg3 = (wxDash*)byte_LIST_helper(obj1);
3453 if (arg3 == NULL) SWIG_fail;
3454 }
3455 {
3456 PyThreadState* __tstate = wxPyBeginAllowThreads();
3457 (arg1)->SetDashes(arg2,arg3);
3458
3459 wxPyEndAllowThreads(__tstate);
3460 if (PyErr_Occurred()) SWIG_fail;
3461 }
3462 Py_INCREF(Py_None); resultobj = Py_None;
3463 {
3464 if (arg3) delete [] arg3;
3465 }
3466 return resultobj;
3467 fail:
3468 {
3469 if (arg3) delete [] arg3;
3470 }
3471 return NULL;
3472 }
3473
3474
3475 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3476 PyObject *resultobj;
3477 wxPen *arg1 = (wxPen *) 0 ;
3478 PyObject *result;
3479 PyObject * obj0 = 0 ;
3480 char *kwnames[] = {
3481 (char *) "self", NULL
3482 };
3483
3484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3486 if (SWIG_arg_fail(1)) SWIG_fail;
3487 {
3488 PyThreadState* __tstate = wxPyBeginAllowThreads();
3489 result = (PyObject *)wxPen_GetDashes(arg1);
3490
3491 wxPyEndAllowThreads(__tstate);
3492 if (PyErr_Occurred()) SWIG_fail;
3493 }
3494 resultobj = result;
3495 return resultobj;
3496 fail:
3497 return NULL;
3498 }
3499
3500
3501 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3502 PyObject *resultobj;
3503 wxPen *arg1 = (wxPen *) 0 ;
3504 PyObject *arg2 = (PyObject *) 0 ;
3505 PyObject *arg3 = (PyObject *) 0 ;
3506 PyObject * obj0 = 0 ;
3507 PyObject * obj1 = 0 ;
3508 PyObject * obj2 = 0 ;
3509 char *kwnames[] = {
3510 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3511 };
3512
3513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3515 if (SWIG_arg_fail(1)) SWIG_fail;
3516 arg2 = obj1;
3517 arg3 = obj2;
3518 {
3519 PyThreadState* __tstate = wxPyBeginAllowThreads();
3520 wxPen__SetDashes(arg1,arg2,arg3);
3521
3522 wxPyEndAllowThreads(__tstate);
3523 if (PyErr_Occurred()) SWIG_fail;
3524 }
3525 Py_INCREF(Py_None); resultobj = Py_None;
3526 return resultobj;
3527 fail:
3528 return NULL;
3529 }
3530
3531
3532 static PyObject *_wrap_Pen_GetDashCount(PyObject *, PyObject *args, PyObject *kwargs) {
3533 PyObject *resultobj;
3534 wxPen *arg1 = (wxPen *) 0 ;
3535 int result;
3536 PyObject * obj0 = 0 ;
3537 char *kwnames[] = {
3538 (char *) "self", NULL
3539 };
3540
3541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashCount",kwnames,&obj0)) goto fail;
3542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3543 if (SWIG_arg_fail(1)) SWIG_fail;
3544 {
3545 PyThreadState* __tstate = wxPyBeginAllowThreads();
3546 result = (int)((wxPen const *)arg1)->GetDashCount();
3547
3548 wxPyEndAllowThreads(__tstate);
3549 if (PyErr_Occurred()) SWIG_fail;
3550 }
3551 {
3552 resultobj = SWIG_From_int((int)(result));
3553 }
3554 return resultobj;
3555 fail:
3556 return NULL;
3557 }
3558
3559
3560 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3561 PyObject *resultobj;
3562 wxPen *arg1 = (wxPen *) 0 ;
3563 wxPen *arg2 = (wxPen *) 0 ;
3564 bool result;
3565 PyObject * obj0 = 0 ;
3566 PyObject * obj1 = 0 ;
3567 char *kwnames[] = {
3568 (char *) "self",(char *) "other", NULL
3569 };
3570
3571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3573 if (SWIG_arg_fail(1)) SWIG_fail;
3574 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3575 if (SWIG_arg_fail(2)) SWIG_fail;
3576 {
3577 PyThreadState* __tstate = wxPyBeginAllowThreads();
3578 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3579
3580 wxPyEndAllowThreads(__tstate);
3581 if (PyErr_Occurred()) SWIG_fail;
3582 }
3583 {
3584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3585 }
3586 return resultobj;
3587 fail:
3588 return NULL;
3589 }
3590
3591
3592 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3593 PyObject *resultobj;
3594 wxPen *arg1 = (wxPen *) 0 ;
3595 wxPen *arg2 = (wxPen *) 0 ;
3596 bool result;
3597 PyObject * obj0 = 0 ;
3598 PyObject * obj1 = 0 ;
3599 char *kwnames[] = {
3600 (char *) "self",(char *) "other", NULL
3601 };
3602
3603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3605 if (SWIG_arg_fail(1)) SWIG_fail;
3606 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3607 if (SWIG_arg_fail(2)) SWIG_fail;
3608 {
3609 PyThreadState* __tstate = wxPyBeginAllowThreads();
3610 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3611
3612 wxPyEndAllowThreads(__tstate);
3613 if (PyErr_Occurred()) SWIG_fail;
3614 }
3615 {
3616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3617 }
3618 return resultobj;
3619 fail:
3620 return NULL;
3621 }
3622
3623
3624 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3625 PyObject *obj;
3626 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3627 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3628 Py_INCREF(obj);
3629 return Py_BuildValue((char *)"");
3630 }
3631 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3632 PyObject *resultobj;
3633 wxColour *arg1 = 0 ;
3634 int arg2 = (int) wxSOLID ;
3635 wxBrush *result;
3636 wxColour temp1 ;
3637 PyObject * obj0 = 0 ;
3638 PyObject * obj1 = 0 ;
3639 char *kwnames[] = {
3640 (char *) "colour",(char *) "style", NULL
3641 };
3642
3643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3644 {
3645 arg1 = &temp1;
3646 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3647 }
3648 if (obj1) {
3649 {
3650 arg2 = (int)(SWIG_As_int(obj1));
3651 if (SWIG_arg_fail(2)) SWIG_fail;
3652 }
3653 }
3654 {
3655 if (!wxPyCheckForApp()) SWIG_fail;
3656 PyThreadState* __tstate = wxPyBeginAllowThreads();
3657 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3658
3659 wxPyEndAllowThreads(__tstate);
3660 if (PyErr_Occurred()) SWIG_fail;
3661 }
3662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3663 return resultobj;
3664 fail:
3665 return NULL;
3666 }
3667
3668
3669 static PyObject *_wrap_new_BrushFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3670 PyObject *resultobj;
3671 wxBitmap *arg1 = 0 ;
3672 wxBrush *result;
3673 PyObject * obj0 = 0 ;
3674 char *kwnames[] = {
3675 (char *) "stippleBitmap", NULL
3676 };
3677
3678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BrushFromBitmap",kwnames,&obj0)) goto fail;
3679 {
3680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3681 if (SWIG_arg_fail(1)) SWIG_fail;
3682 if (arg1 == NULL) {
3683 SWIG_null_ref("wxBitmap");
3684 }
3685 if (SWIG_arg_fail(1)) SWIG_fail;
3686 }
3687 {
3688 if (!wxPyCheckForApp()) SWIG_fail;
3689 PyThreadState* __tstate = wxPyBeginAllowThreads();
3690 result = (wxBrush *)new wxBrush((wxBitmap const &)*arg1);
3691
3692 wxPyEndAllowThreads(__tstate);
3693 if (PyErr_Occurred()) SWIG_fail;
3694 }
3695 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3696 return resultobj;
3697 fail:
3698 return NULL;
3699 }
3700
3701
3702 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3703 PyObject *resultobj;
3704 wxBrush *arg1 = (wxBrush *) 0 ;
3705 PyObject * obj0 = 0 ;
3706 char *kwnames[] = {
3707 (char *) "self", NULL
3708 };
3709
3710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3712 if (SWIG_arg_fail(1)) SWIG_fail;
3713 {
3714 PyThreadState* __tstate = wxPyBeginAllowThreads();
3715 delete arg1;
3716
3717 wxPyEndAllowThreads(__tstate);
3718 if (PyErr_Occurred()) SWIG_fail;
3719 }
3720 Py_INCREF(Py_None); resultobj = Py_None;
3721 return resultobj;
3722 fail:
3723 return NULL;
3724 }
3725
3726
3727 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3728 PyObject *resultobj;
3729 wxBrush *arg1 = (wxBrush *) 0 ;
3730 wxColour *arg2 = 0 ;
3731 wxColour temp2 ;
3732 PyObject * obj0 = 0 ;
3733 PyObject * obj1 = 0 ;
3734 char *kwnames[] = {
3735 (char *) "self",(char *) "col", NULL
3736 };
3737
3738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3740 if (SWIG_arg_fail(1)) SWIG_fail;
3741 {
3742 arg2 = &temp2;
3743 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3744 }
3745 {
3746 PyThreadState* __tstate = wxPyBeginAllowThreads();
3747 (arg1)->SetColour((wxColour const &)*arg2);
3748
3749 wxPyEndAllowThreads(__tstate);
3750 if (PyErr_Occurred()) SWIG_fail;
3751 }
3752 Py_INCREF(Py_None); resultobj = Py_None;
3753 return resultobj;
3754 fail:
3755 return NULL;
3756 }
3757
3758
3759 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3760 PyObject *resultobj;
3761 wxBrush *arg1 = (wxBrush *) 0 ;
3762 int arg2 ;
3763 PyObject * obj0 = 0 ;
3764 PyObject * obj1 = 0 ;
3765 char *kwnames[] = {
3766 (char *) "self",(char *) "style", NULL
3767 };
3768
3769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3771 if (SWIG_arg_fail(1)) SWIG_fail;
3772 {
3773 arg2 = (int)(SWIG_As_int(obj1));
3774 if (SWIG_arg_fail(2)) SWIG_fail;
3775 }
3776 {
3777 PyThreadState* __tstate = wxPyBeginAllowThreads();
3778 (arg1)->SetStyle(arg2);
3779
3780 wxPyEndAllowThreads(__tstate);
3781 if (PyErr_Occurred()) SWIG_fail;
3782 }
3783 Py_INCREF(Py_None); resultobj = Py_None;
3784 return resultobj;
3785 fail:
3786 return NULL;
3787 }
3788
3789
3790 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3791 PyObject *resultobj;
3792 wxBrush *arg1 = (wxBrush *) 0 ;
3793 wxBitmap *arg2 = 0 ;
3794 PyObject * obj0 = 0 ;
3795 PyObject * obj1 = 0 ;
3796 char *kwnames[] = {
3797 (char *) "self",(char *) "stipple", NULL
3798 };
3799
3800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3802 if (SWIG_arg_fail(1)) SWIG_fail;
3803 {
3804 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3805 if (SWIG_arg_fail(2)) SWIG_fail;
3806 if (arg2 == NULL) {
3807 SWIG_null_ref("wxBitmap");
3808 }
3809 if (SWIG_arg_fail(2)) SWIG_fail;
3810 }
3811 {
3812 PyThreadState* __tstate = wxPyBeginAllowThreads();
3813 (arg1)->SetStipple((wxBitmap const &)*arg2);
3814
3815 wxPyEndAllowThreads(__tstate);
3816 if (PyErr_Occurred()) SWIG_fail;
3817 }
3818 Py_INCREF(Py_None); resultobj = Py_None;
3819 return resultobj;
3820 fail:
3821 return NULL;
3822 }
3823
3824
3825 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3826 PyObject *resultobj;
3827 wxBrush *arg1 = (wxBrush *) 0 ;
3828 wxColour result;
3829 PyObject * obj0 = 0 ;
3830 char *kwnames[] = {
3831 (char *) "self", NULL
3832 };
3833
3834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3836 if (SWIG_arg_fail(1)) SWIG_fail;
3837 {
3838 PyThreadState* __tstate = wxPyBeginAllowThreads();
3839 result = ((wxBrush const *)arg1)->GetColour();
3840
3841 wxPyEndAllowThreads(__tstate);
3842 if (PyErr_Occurred()) SWIG_fail;
3843 }
3844 {
3845 wxColour * resultptr;
3846 resultptr = new wxColour((wxColour &)(result));
3847 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3848 }
3849 return resultobj;
3850 fail:
3851 return NULL;
3852 }
3853
3854
3855 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3856 PyObject *resultobj;
3857 wxBrush *arg1 = (wxBrush *) 0 ;
3858 int result;
3859 PyObject * obj0 = 0 ;
3860 char *kwnames[] = {
3861 (char *) "self", NULL
3862 };
3863
3864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3866 if (SWIG_arg_fail(1)) SWIG_fail;
3867 {
3868 PyThreadState* __tstate = wxPyBeginAllowThreads();
3869 result = (int)((wxBrush const *)arg1)->GetStyle();
3870
3871 wxPyEndAllowThreads(__tstate);
3872 if (PyErr_Occurred()) SWIG_fail;
3873 }
3874 {
3875 resultobj = SWIG_From_int((int)(result));
3876 }
3877 return resultobj;
3878 fail:
3879 return NULL;
3880 }
3881
3882
3883 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3884 PyObject *resultobj;
3885 wxBrush *arg1 = (wxBrush *) 0 ;
3886 wxBitmap *result;
3887 PyObject * obj0 = 0 ;
3888 char *kwnames[] = {
3889 (char *) "self", NULL
3890 };
3891
3892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3894 if (SWIG_arg_fail(1)) SWIG_fail;
3895 {
3896 PyThreadState* __tstate = wxPyBeginAllowThreads();
3897 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3898
3899 wxPyEndAllowThreads(__tstate);
3900 if (PyErr_Occurred()) SWIG_fail;
3901 }
3902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3903 return resultobj;
3904 fail:
3905 return NULL;
3906 }
3907
3908
3909 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3910 PyObject *resultobj;
3911 wxBrush *arg1 = (wxBrush *) 0 ;
3912 bool result;
3913 PyObject * obj0 = 0 ;
3914 char *kwnames[] = {
3915 (char *) "self", NULL
3916 };
3917
3918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3920 if (SWIG_arg_fail(1)) SWIG_fail;
3921 {
3922 PyThreadState* __tstate = wxPyBeginAllowThreads();
3923 result = (bool)((wxBrush const *)arg1)->IsHatch();
3924
3925 wxPyEndAllowThreads(__tstate);
3926 if (PyErr_Occurred()) SWIG_fail;
3927 }
3928 {
3929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3930 }
3931 return resultobj;
3932 fail:
3933 return NULL;
3934 }
3935
3936
3937 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3938 PyObject *resultobj;
3939 wxBrush *arg1 = (wxBrush *) 0 ;
3940 bool result;
3941 PyObject * obj0 = 0 ;
3942 char *kwnames[] = {
3943 (char *) "self", NULL
3944 };
3945
3946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3948 if (SWIG_arg_fail(1)) SWIG_fail;
3949 {
3950 PyThreadState* __tstate = wxPyBeginAllowThreads();
3951 result = (bool)(arg1)->Ok();
3952
3953 wxPyEndAllowThreads(__tstate);
3954 if (PyErr_Occurred()) SWIG_fail;
3955 }
3956 {
3957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3958 }
3959 return resultobj;
3960 fail:
3961 return NULL;
3962 }
3963
3964
3965 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
3966 PyObject *obj;
3967 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3968 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
3969 Py_INCREF(obj);
3970 return Py_BuildValue((char *)"");
3971 }
3972 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3973 PyObject *resultobj;
3974 wxString *arg1 = 0 ;
3975 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
3976 wxBitmap *result;
3977 bool temp1 = false ;
3978 PyObject * obj0 = 0 ;
3979 PyObject * obj1 = 0 ;
3980 char *kwnames[] = {
3981 (char *) "name",(char *) "type", NULL
3982 };
3983
3984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
3985 {
3986 arg1 = wxString_in_helper(obj0);
3987 if (arg1 == NULL) SWIG_fail;
3988 temp1 = true;
3989 }
3990 if (obj1) {
3991 {
3992 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
3993 if (SWIG_arg_fail(2)) SWIG_fail;
3994 }
3995 }
3996 {
3997 if (!wxPyCheckForApp()) SWIG_fail;
3998 PyThreadState* __tstate = wxPyBeginAllowThreads();
3999 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
4000
4001 wxPyEndAllowThreads(__tstate);
4002 if (PyErr_Occurred()) SWIG_fail;
4003 }
4004 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4005 {
4006 if (temp1)
4007 delete arg1;
4008 }
4009 return resultobj;
4010 fail:
4011 {
4012 if (temp1)
4013 delete arg1;
4014 }
4015 return NULL;
4016 }
4017
4018
4019 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4020 PyObject *resultobj;
4021 wxBitmap *arg1 = (wxBitmap *) 0 ;
4022 PyObject * obj0 = 0 ;
4023 char *kwnames[] = {
4024 (char *) "self", NULL
4025 };
4026
4027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
4028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4029 if (SWIG_arg_fail(1)) SWIG_fail;
4030 {
4031 PyThreadState* __tstate = wxPyBeginAllowThreads();
4032 delete arg1;
4033
4034 wxPyEndAllowThreads(__tstate);
4035 if (PyErr_Occurred()) SWIG_fail;
4036 }
4037 Py_INCREF(Py_None); resultobj = Py_None;
4038 return resultobj;
4039 fail:
4040 return NULL;
4041 }
4042
4043
4044 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4045 PyObject *resultobj;
4046 int arg1 ;
4047 int arg2 ;
4048 int arg3 = (int) -1 ;
4049 wxBitmap *result;
4050 PyObject * obj0 = 0 ;
4051 PyObject * obj1 = 0 ;
4052 PyObject * obj2 = 0 ;
4053 char *kwnames[] = {
4054 (char *) "width",(char *) "height",(char *) "depth", NULL
4055 };
4056
4057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4058 {
4059 arg1 = (int)(SWIG_As_int(obj0));
4060 if (SWIG_arg_fail(1)) SWIG_fail;
4061 }
4062 {
4063 arg2 = (int)(SWIG_As_int(obj1));
4064 if (SWIG_arg_fail(2)) SWIG_fail;
4065 }
4066 if (obj2) {
4067 {
4068 arg3 = (int)(SWIG_As_int(obj2));
4069 if (SWIG_arg_fail(3)) SWIG_fail;
4070 }
4071 }
4072 {
4073 if (!wxPyCheckForApp()) SWIG_fail;
4074 PyThreadState* __tstate = wxPyBeginAllowThreads();
4075 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4076
4077 wxPyEndAllowThreads(__tstate);
4078 if (PyErr_Occurred()) SWIG_fail;
4079 }
4080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4081 return resultobj;
4082 fail:
4083 return NULL;
4084 }
4085
4086
4087 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4088 PyObject *resultobj;
4089 wxIcon *arg1 = 0 ;
4090 wxBitmap *result;
4091 PyObject * obj0 = 0 ;
4092 char *kwnames[] = {
4093 (char *) "icon", NULL
4094 };
4095
4096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4097 {
4098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4099 if (SWIG_arg_fail(1)) SWIG_fail;
4100 if (arg1 == NULL) {
4101 SWIG_null_ref("wxIcon");
4102 }
4103 if (SWIG_arg_fail(1)) SWIG_fail;
4104 }
4105 {
4106 if (!wxPyCheckForApp()) SWIG_fail;
4107 PyThreadState* __tstate = wxPyBeginAllowThreads();
4108 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4109
4110 wxPyEndAllowThreads(__tstate);
4111 if (PyErr_Occurred()) SWIG_fail;
4112 }
4113 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4114 return resultobj;
4115 fail:
4116 return NULL;
4117 }
4118
4119
4120 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4121 PyObject *resultobj;
4122 wxImage *arg1 = 0 ;
4123 int arg2 = (int) -1 ;
4124 wxBitmap *result;
4125 PyObject * obj0 = 0 ;
4126 PyObject * obj1 = 0 ;
4127 char *kwnames[] = {
4128 (char *) "image",(char *) "depth", NULL
4129 };
4130
4131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4132 {
4133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4134 if (SWIG_arg_fail(1)) SWIG_fail;
4135 if (arg1 == NULL) {
4136 SWIG_null_ref("wxImage");
4137 }
4138 if (SWIG_arg_fail(1)) SWIG_fail;
4139 }
4140 if (obj1) {
4141 {
4142 arg2 = (int)(SWIG_As_int(obj1));
4143 if (SWIG_arg_fail(2)) SWIG_fail;
4144 }
4145 }
4146 {
4147 if (!wxPyCheckForApp()) SWIG_fail;
4148 PyThreadState* __tstate = wxPyBeginAllowThreads();
4149 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4150
4151 wxPyEndAllowThreads(__tstate);
4152 if (PyErr_Occurred()) SWIG_fail;
4153 }
4154 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4155 return resultobj;
4156 fail:
4157 return NULL;
4158 }
4159
4160
4161 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4162 PyObject *resultobj;
4163 PyObject *arg1 = (PyObject *) 0 ;
4164 wxBitmap *result;
4165 PyObject * obj0 = 0 ;
4166 char *kwnames[] = {
4167 (char *) "listOfStrings", NULL
4168 };
4169
4170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4171 arg1 = obj0;
4172 {
4173 if (!wxPyCheckForApp()) SWIG_fail;
4174 PyThreadState* __tstate = wxPyBeginAllowThreads();
4175 result = (wxBitmap *)new_wxBitmap(arg1);
4176
4177 wxPyEndAllowThreads(__tstate);
4178 if (PyErr_Occurred()) SWIG_fail;
4179 }
4180 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4181 return resultobj;
4182 fail:
4183 return NULL;
4184 }
4185
4186
4187 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4188 PyObject *resultobj;
4189 PyObject *arg1 = (PyObject *) 0 ;
4190 int arg2 ;
4191 int arg3 ;
4192 int arg4 = (int) 1 ;
4193 wxBitmap *result;
4194 PyObject * obj0 = 0 ;
4195 PyObject * obj1 = 0 ;
4196 PyObject * obj2 = 0 ;
4197 PyObject * obj3 = 0 ;
4198 char *kwnames[] = {
4199 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4200 };
4201
4202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4203 arg1 = obj0;
4204 {
4205 arg2 = (int)(SWIG_As_int(obj1));
4206 if (SWIG_arg_fail(2)) SWIG_fail;
4207 }
4208 {
4209 arg3 = (int)(SWIG_As_int(obj2));
4210 if (SWIG_arg_fail(3)) SWIG_fail;
4211 }
4212 if (obj3) {
4213 {
4214 arg4 = (int)(SWIG_As_int(obj3));
4215 if (SWIG_arg_fail(4)) SWIG_fail;
4216 }
4217 }
4218 {
4219 if (!wxPyCheckForApp()) SWIG_fail;
4220 PyThreadState* __tstate = wxPyBeginAllowThreads();
4221 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4222
4223 wxPyEndAllowThreads(__tstate);
4224 if (PyErr_Occurred()) SWIG_fail;
4225 }
4226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4227 return resultobj;
4228 fail:
4229 return NULL;
4230 }
4231
4232
4233 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4234 PyObject *resultobj;
4235 wxBitmap *arg1 = (wxBitmap *) 0 ;
4236 bool result;
4237 PyObject * obj0 = 0 ;
4238 char *kwnames[] = {
4239 (char *) "self", NULL
4240 };
4241
4242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4244 if (SWIG_arg_fail(1)) SWIG_fail;
4245 {
4246 PyThreadState* __tstate = wxPyBeginAllowThreads();
4247 result = (bool)(arg1)->Ok();
4248
4249 wxPyEndAllowThreads(__tstate);
4250 if (PyErr_Occurred()) SWIG_fail;
4251 }
4252 {
4253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4254 }
4255 return resultobj;
4256 fail:
4257 return NULL;
4258 }
4259
4260
4261 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4262 PyObject *resultobj;
4263 wxBitmap *arg1 = (wxBitmap *) 0 ;
4264 int result;
4265 PyObject * obj0 = 0 ;
4266 char *kwnames[] = {
4267 (char *) "self", NULL
4268 };
4269
4270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4272 if (SWIG_arg_fail(1)) SWIG_fail;
4273 {
4274 PyThreadState* __tstate = wxPyBeginAllowThreads();
4275 result = (int)(arg1)->GetWidth();
4276
4277 wxPyEndAllowThreads(__tstate);
4278 if (PyErr_Occurred()) SWIG_fail;
4279 }
4280 {
4281 resultobj = SWIG_From_int((int)(result));
4282 }
4283 return resultobj;
4284 fail:
4285 return NULL;
4286 }
4287
4288
4289 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4290 PyObject *resultobj;
4291 wxBitmap *arg1 = (wxBitmap *) 0 ;
4292 int result;
4293 PyObject * obj0 = 0 ;
4294 char *kwnames[] = {
4295 (char *) "self", NULL
4296 };
4297
4298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4300 if (SWIG_arg_fail(1)) SWIG_fail;
4301 {
4302 PyThreadState* __tstate = wxPyBeginAllowThreads();
4303 result = (int)(arg1)->GetHeight();
4304
4305 wxPyEndAllowThreads(__tstate);
4306 if (PyErr_Occurred()) SWIG_fail;
4307 }
4308 {
4309 resultobj = SWIG_From_int((int)(result));
4310 }
4311 return resultobj;
4312 fail:
4313 return NULL;
4314 }
4315
4316
4317 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4318 PyObject *resultobj;
4319 wxBitmap *arg1 = (wxBitmap *) 0 ;
4320 int result;
4321 PyObject * obj0 = 0 ;
4322 char *kwnames[] = {
4323 (char *) "self", NULL
4324 };
4325
4326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4328 if (SWIG_arg_fail(1)) SWIG_fail;
4329 {
4330 PyThreadState* __tstate = wxPyBeginAllowThreads();
4331 result = (int)(arg1)->GetDepth();
4332
4333 wxPyEndAllowThreads(__tstate);
4334 if (PyErr_Occurred()) SWIG_fail;
4335 }
4336 {
4337 resultobj = SWIG_From_int((int)(result));
4338 }
4339 return resultobj;
4340 fail:
4341 return NULL;
4342 }
4343
4344
4345 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4346 PyObject *resultobj;
4347 wxBitmap *arg1 = (wxBitmap *) 0 ;
4348 wxSize result;
4349 PyObject * obj0 = 0 ;
4350 char *kwnames[] = {
4351 (char *) "self", NULL
4352 };
4353
4354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4356 if (SWIG_arg_fail(1)) SWIG_fail;
4357 {
4358 PyThreadState* __tstate = wxPyBeginAllowThreads();
4359 result = wxBitmap_GetSize(arg1);
4360
4361 wxPyEndAllowThreads(__tstate);
4362 if (PyErr_Occurred()) SWIG_fail;
4363 }
4364 {
4365 wxSize * resultptr;
4366 resultptr = new wxSize((wxSize &)(result));
4367 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4368 }
4369 return resultobj;
4370 fail:
4371 return NULL;
4372 }
4373
4374
4375 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4376 PyObject *resultobj;
4377 wxBitmap *arg1 = (wxBitmap *) 0 ;
4378 SwigValueWrapper<wxImage > result;
4379 PyObject * obj0 = 0 ;
4380 char *kwnames[] = {
4381 (char *) "self", NULL
4382 };
4383
4384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4386 if (SWIG_arg_fail(1)) SWIG_fail;
4387 {
4388 PyThreadState* __tstate = wxPyBeginAllowThreads();
4389 result = ((wxBitmap const *)arg1)->ConvertToImage();
4390
4391 wxPyEndAllowThreads(__tstate);
4392 if (PyErr_Occurred()) SWIG_fail;
4393 }
4394 {
4395 wxImage * resultptr;
4396 resultptr = new wxImage((wxImage &)(result));
4397 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4398 }
4399 return resultobj;
4400 fail:
4401 return NULL;
4402 }
4403
4404
4405 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4406 PyObject *resultobj;
4407 wxBitmap *arg1 = (wxBitmap *) 0 ;
4408 wxMask *result;
4409 PyObject * obj0 = 0 ;
4410 char *kwnames[] = {
4411 (char *) "self", NULL
4412 };
4413
4414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4416 if (SWIG_arg_fail(1)) SWIG_fail;
4417 {
4418 PyThreadState* __tstate = wxPyBeginAllowThreads();
4419 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4420
4421 wxPyEndAllowThreads(__tstate);
4422 if (PyErr_Occurred()) SWIG_fail;
4423 }
4424 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4425 return resultobj;
4426 fail:
4427 return NULL;
4428 }
4429
4430
4431 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4432 PyObject *resultobj;
4433 wxBitmap *arg1 = (wxBitmap *) 0 ;
4434 wxMask *arg2 = (wxMask *) 0 ;
4435 PyObject * obj0 = 0 ;
4436 PyObject * obj1 = 0 ;
4437 char *kwnames[] = {
4438 (char *) "self",(char *) "mask", NULL
4439 };
4440
4441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4443 if (SWIG_arg_fail(1)) SWIG_fail;
4444 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4445 if (SWIG_arg_fail(2)) SWIG_fail;
4446 {
4447 PyThreadState* __tstate = wxPyBeginAllowThreads();
4448 (arg1)->SetMask(arg2);
4449
4450 wxPyEndAllowThreads(__tstate);
4451 if (PyErr_Occurred()) SWIG_fail;
4452 }
4453 Py_INCREF(Py_None); resultobj = Py_None;
4454 return resultobj;
4455 fail:
4456 return NULL;
4457 }
4458
4459
4460 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4461 PyObject *resultobj;
4462 wxBitmap *arg1 = (wxBitmap *) 0 ;
4463 wxColour *arg2 = 0 ;
4464 wxColour temp2 ;
4465 PyObject * obj0 = 0 ;
4466 PyObject * obj1 = 0 ;
4467 char *kwnames[] = {
4468 (char *) "self",(char *) "colour", NULL
4469 };
4470
4471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4473 if (SWIG_arg_fail(1)) SWIG_fail;
4474 {
4475 arg2 = &temp2;
4476 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4477 }
4478 {
4479 PyThreadState* __tstate = wxPyBeginAllowThreads();
4480 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4481
4482 wxPyEndAllowThreads(__tstate);
4483 if (PyErr_Occurred()) SWIG_fail;
4484 }
4485 Py_INCREF(Py_None); resultobj = Py_None;
4486 return resultobj;
4487 fail:
4488 return NULL;
4489 }
4490
4491
4492 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4493 PyObject *resultobj;
4494 wxBitmap *arg1 = (wxBitmap *) 0 ;
4495 wxRect *arg2 = 0 ;
4496 SwigValueWrapper<wxBitmap > result;
4497 wxRect temp2 ;
4498 PyObject * obj0 = 0 ;
4499 PyObject * obj1 = 0 ;
4500 char *kwnames[] = {
4501 (char *) "self",(char *) "rect", NULL
4502 };
4503
4504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4506 if (SWIG_arg_fail(1)) SWIG_fail;
4507 {
4508 arg2 = &temp2;
4509 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4510 }
4511 {
4512 PyThreadState* __tstate = wxPyBeginAllowThreads();
4513 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4514
4515 wxPyEndAllowThreads(__tstate);
4516 if (PyErr_Occurred()) SWIG_fail;
4517 }
4518 {
4519 wxBitmap * resultptr;
4520 resultptr = new wxBitmap((wxBitmap &)(result));
4521 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4522 }
4523 return resultobj;
4524 fail:
4525 return NULL;
4526 }
4527
4528
4529 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4530 PyObject *resultobj;
4531 wxBitmap *arg1 = (wxBitmap *) 0 ;
4532 wxString *arg2 = 0 ;
4533 wxBitmapType arg3 ;
4534 wxPalette *arg4 = (wxPalette *) NULL ;
4535 bool result;
4536 bool temp2 = false ;
4537 PyObject * obj0 = 0 ;
4538 PyObject * obj1 = 0 ;
4539 PyObject * obj2 = 0 ;
4540 PyObject * obj3 = 0 ;
4541 char *kwnames[] = {
4542 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4543 };
4544
4545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4547 if (SWIG_arg_fail(1)) SWIG_fail;
4548 {
4549 arg2 = wxString_in_helper(obj1);
4550 if (arg2 == NULL) SWIG_fail;
4551 temp2 = true;
4552 }
4553 {
4554 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4555 if (SWIG_arg_fail(3)) SWIG_fail;
4556 }
4557 if (obj3) {
4558 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4559 if (SWIG_arg_fail(4)) SWIG_fail;
4560 }
4561 {
4562 PyThreadState* __tstate = wxPyBeginAllowThreads();
4563 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4564
4565 wxPyEndAllowThreads(__tstate);
4566 if (PyErr_Occurred()) SWIG_fail;
4567 }
4568 {
4569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4570 }
4571 {
4572 if (temp2)
4573 delete arg2;
4574 }
4575 return resultobj;
4576 fail:
4577 {
4578 if (temp2)
4579 delete arg2;
4580 }
4581 return NULL;
4582 }
4583
4584
4585 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4586 PyObject *resultobj;
4587 wxBitmap *arg1 = (wxBitmap *) 0 ;
4588 wxString *arg2 = 0 ;
4589 wxBitmapType arg3 ;
4590 bool result;
4591 bool temp2 = false ;
4592 PyObject * obj0 = 0 ;
4593 PyObject * obj1 = 0 ;
4594 PyObject * obj2 = 0 ;
4595 char *kwnames[] = {
4596 (char *) "self",(char *) "name",(char *) "type", NULL
4597 };
4598
4599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4601 if (SWIG_arg_fail(1)) SWIG_fail;
4602 {
4603 arg2 = wxString_in_helper(obj1);
4604 if (arg2 == NULL) SWIG_fail;
4605 temp2 = true;
4606 }
4607 {
4608 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4609 if (SWIG_arg_fail(3)) SWIG_fail;
4610 }
4611 {
4612 PyThreadState* __tstate = wxPyBeginAllowThreads();
4613 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4614
4615 wxPyEndAllowThreads(__tstate);
4616 if (PyErr_Occurred()) SWIG_fail;
4617 }
4618 {
4619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4620 }
4621 {
4622 if (temp2)
4623 delete arg2;
4624 }
4625 return resultobj;
4626 fail:
4627 {
4628 if (temp2)
4629 delete arg2;
4630 }
4631 return NULL;
4632 }
4633
4634
4635 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4636 PyObject *resultobj;
4637 wxBitmap *arg1 = (wxBitmap *) 0 ;
4638 wxPalette *result;
4639 PyObject * obj0 = 0 ;
4640 char *kwnames[] = {
4641 (char *) "self", NULL
4642 };
4643
4644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4646 if (SWIG_arg_fail(1)) SWIG_fail;
4647 {
4648 PyThreadState* __tstate = wxPyBeginAllowThreads();
4649 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4650
4651 wxPyEndAllowThreads(__tstate);
4652 if (PyErr_Occurred()) SWIG_fail;
4653 }
4654 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4655 return resultobj;
4656 fail:
4657 return NULL;
4658 }
4659
4660
4661 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4662 PyObject *resultobj;
4663 wxBitmap *arg1 = (wxBitmap *) 0 ;
4664 wxIcon *arg2 = 0 ;
4665 bool result;
4666 PyObject * obj0 = 0 ;
4667 PyObject * obj1 = 0 ;
4668 char *kwnames[] = {
4669 (char *) "self",(char *) "icon", NULL
4670 };
4671
4672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4674 if (SWIG_arg_fail(1)) SWIG_fail;
4675 {
4676 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4677 if (SWIG_arg_fail(2)) SWIG_fail;
4678 if (arg2 == NULL) {
4679 SWIG_null_ref("wxIcon");
4680 }
4681 if (SWIG_arg_fail(2)) SWIG_fail;
4682 }
4683 {
4684 PyThreadState* __tstate = wxPyBeginAllowThreads();
4685 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4686
4687 wxPyEndAllowThreads(__tstate);
4688 if (PyErr_Occurred()) SWIG_fail;
4689 }
4690 {
4691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4692 }
4693 return resultobj;
4694 fail:
4695 return NULL;
4696 }
4697
4698
4699 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4700 PyObject *resultobj;
4701 wxBitmap *arg1 = (wxBitmap *) 0 ;
4702 int arg2 ;
4703 PyObject * obj0 = 0 ;
4704 PyObject * obj1 = 0 ;
4705 char *kwnames[] = {
4706 (char *) "self",(char *) "height", NULL
4707 };
4708
4709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
4714 if (SWIG_arg_fail(2)) SWIG_fail;
4715 }
4716 {
4717 PyThreadState* __tstate = wxPyBeginAllowThreads();
4718 (arg1)->SetHeight(arg2);
4719
4720 wxPyEndAllowThreads(__tstate);
4721 if (PyErr_Occurred()) SWIG_fail;
4722 }
4723 Py_INCREF(Py_None); resultobj = Py_None;
4724 return resultobj;
4725 fail:
4726 return NULL;
4727 }
4728
4729
4730 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4731 PyObject *resultobj;
4732 wxBitmap *arg1 = (wxBitmap *) 0 ;
4733 int arg2 ;
4734 PyObject * obj0 = 0 ;
4735 PyObject * obj1 = 0 ;
4736 char *kwnames[] = {
4737 (char *) "self",(char *) "width", NULL
4738 };
4739
4740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4742 if (SWIG_arg_fail(1)) SWIG_fail;
4743 {
4744 arg2 = (int)(SWIG_As_int(obj1));
4745 if (SWIG_arg_fail(2)) SWIG_fail;
4746 }
4747 {
4748 PyThreadState* __tstate = wxPyBeginAllowThreads();
4749 (arg1)->SetWidth(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_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4762 PyObject *resultobj;
4763 wxBitmap *arg1 = (wxBitmap *) 0 ;
4764 int arg2 ;
4765 PyObject * obj0 = 0 ;
4766 PyObject * obj1 = 0 ;
4767 char *kwnames[] = {
4768 (char *) "self",(char *) "depth", NULL
4769 };
4770
4771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4773 if (SWIG_arg_fail(1)) SWIG_fail;
4774 {
4775 arg2 = (int)(SWIG_As_int(obj1));
4776 if (SWIG_arg_fail(2)) SWIG_fail;
4777 }
4778 {
4779 PyThreadState* __tstate = wxPyBeginAllowThreads();
4780 (arg1)->SetDepth(arg2);
4781
4782 wxPyEndAllowThreads(__tstate);
4783 if (PyErr_Occurred()) SWIG_fail;
4784 }
4785 Py_INCREF(Py_None); resultobj = Py_None;
4786 return resultobj;
4787 fail:
4788 return NULL;
4789 }
4790
4791
4792 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4793 PyObject *resultobj;
4794 wxBitmap *arg1 = (wxBitmap *) 0 ;
4795 wxSize *arg2 = 0 ;
4796 wxSize temp2 ;
4797 PyObject * obj0 = 0 ;
4798 PyObject * obj1 = 0 ;
4799 char *kwnames[] = {
4800 (char *) "self",(char *) "size", NULL
4801 };
4802
4803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4805 if (SWIG_arg_fail(1)) SWIG_fail;
4806 {
4807 arg2 = &temp2;
4808 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4809 }
4810 {
4811 PyThreadState* __tstate = wxPyBeginAllowThreads();
4812 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4813
4814 wxPyEndAllowThreads(__tstate);
4815 if (PyErr_Occurred()) SWIG_fail;
4816 }
4817 Py_INCREF(Py_None); resultobj = Py_None;
4818 return resultobj;
4819 fail:
4820 return NULL;
4821 }
4822
4823
4824 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4825 PyObject *resultobj;
4826 wxBitmap *arg1 = (wxBitmap *) 0 ;
4827 wxBitmap *arg2 = (wxBitmap *) 0 ;
4828 bool result;
4829 PyObject * obj0 = 0 ;
4830 PyObject * obj1 = 0 ;
4831 char *kwnames[] = {
4832 (char *) "self",(char *) "other", NULL
4833 };
4834
4835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
4836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4837 if (SWIG_arg_fail(1)) SWIG_fail;
4838 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4839 if (SWIG_arg_fail(2)) SWIG_fail;
4840 {
4841 PyThreadState* __tstate = wxPyBeginAllowThreads();
4842 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
4843
4844 wxPyEndAllowThreads(__tstate);
4845 if (PyErr_Occurred()) SWIG_fail;
4846 }
4847 {
4848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4849 }
4850 return resultobj;
4851 fail:
4852 return NULL;
4853 }
4854
4855
4856 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4857 PyObject *resultobj;
4858 wxBitmap *arg1 = (wxBitmap *) 0 ;
4859 wxBitmap *arg2 = (wxBitmap *) 0 ;
4860 bool result;
4861 PyObject * obj0 = 0 ;
4862 PyObject * obj1 = 0 ;
4863 char *kwnames[] = {
4864 (char *) "self",(char *) "other", NULL
4865 };
4866
4867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
4868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4869 if (SWIG_arg_fail(1)) SWIG_fail;
4870 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4871 if (SWIG_arg_fail(2)) SWIG_fail;
4872 {
4873 PyThreadState* __tstate = wxPyBeginAllowThreads();
4874 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
4875
4876 wxPyEndAllowThreads(__tstate);
4877 if (PyErr_Occurred()) SWIG_fail;
4878 }
4879 {
4880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4881 }
4882 return resultobj;
4883 fail:
4884 return NULL;
4885 }
4886
4887
4888 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
4889 PyObject *obj;
4890 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4891 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
4892 Py_INCREF(obj);
4893 return Py_BuildValue((char *)"");
4894 }
4895 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
4896 PyObject *resultobj;
4897 wxBitmap *arg1 = 0 ;
4898 wxColour const &arg2_defvalue = wxNullColour ;
4899 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
4900 wxMask *result;
4901 wxColour temp2 ;
4902 PyObject * obj0 = 0 ;
4903 PyObject * obj1 = 0 ;
4904 char *kwnames[] = {
4905 (char *) "bitmap",(char *) "colour", NULL
4906 };
4907
4908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
4909 {
4910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4911 if (SWIG_arg_fail(1)) SWIG_fail;
4912 if (arg1 == NULL) {
4913 SWIG_null_ref("wxBitmap");
4914 }
4915 if (SWIG_arg_fail(1)) SWIG_fail;
4916 }
4917 if (obj1) {
4918 {
4919 arg2 = &temp2;
4920 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4921 }
4922 }
4923 {
4924 if (!wxPyCheckForApp()) SWIG_fail;
4925 PyThreadState* __tstate = wxPyBeginAllowThreads();
4926 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
4927
4928 wxPyEndAllowThreads(__tstate);
4929 if (PyErr_Occurred()) SWIG_fail;
4930 }
4931 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
4932 return resultobj;
4933 fail:
4934 return NULL;
4935 }
4936
4937
4938 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
4939 PyObject *obj;
4940 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4941 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
4942 Py_INCREF(obj);
4943 return Py_BuildValue((char *)"");
4944 }
4945 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
4946 PyObject *resultobj;
4947 wxString *arg1 = 0 ;
4948 wxBitmapType arg2 ;
4949 int arg3 = (int) -1 ;
4950 int arg4 = (int) -1 ;
4951 wxIcon *result;
4952 bool temp1 = false ;
4953 PyObject * obj0 = 0 ;
4954 PyObject * obj1 = 0 ;
4955 PyObject * obj2 = 0 ;
4956 PyObject * obj3 = 0 ;
4957 char *kwnames[] = {
4958 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
4959 };
4960
4961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4962 {
4963 arg1 = wxString_in_helper(obj0);
4964 if (arg1 == NULL) SWIG_fail;
4965 temp1 = true;
4966 }
4967 {
4968 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4969 if (SWIG_arg_fail(2)) SWIG_fail;
4970 }
4971 if (obj2) {
4972 {
4973 arg3 = (int)(SWIG_As_int(obj2));
4974 if (SWIG_arg_fail(3)) SWIG_fail;
4975 }
4976 }
4977 if (obj3) {
4978 {
4979 arg4 = (int)(SWIG_As_int(obj3));
4980 if (SWIG_arg_fail(4)) SWIG_fail;
4981 }
4982 }
4983 {
4984 if (!wxPyCheckForApp()) SWIG_fail;
4985 PyThreadState* __tstate = wxPyBeginAllowThreads();
4986 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
4987
4988 wxPyEndAllowThreads(__tstate);
4989 if (PyErr_Occurred()) SWIG_fail;
4990 }
4991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
4992 {
4993 if (temp1)
4994 delete arg1;
4995 }
4996 return resultobj;
4997 fail:
4998 {
4999 if (temp1)
5000 delete arg1;
5001 }
5002 return NULL;
5003 }
5004
5005
5006 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5007 PyObject *resultobj;
5008 wxIcon *arg1 = (wxIcon *) 0 ;
5009 PyObject * obj0 = 0 ;
5010 char *kwnames[] = {
5011 (char *) "self", NULL
5012 };
5013
5014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
5015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5016 if (SWIG_arg_fail(1)) SWIG_fail;
5017 {
5018 PyThreadState* __tstate = wxPyBeginAllowThreads();
5019 delete arg1;
5020
5021 wxPyEndAllowThreads(__tstate);
5022 if (PyErr_Occurred()) SWIG_fail;
5023 }
5024 Py_INCREF(Py_None); resultobj = Py_None;
5025 return resultobj;
5026 fail:
5027 return NULL;
5028 }
5029
5030
5031 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5032 PyObject *resultobj;
5033 wxIcon *result;
5034 char *kwnames[] = {
5035 NULL
5036 };
5037
5038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5039 {
5040 if (!wxPyCheckForApp()) SWIG_fail;
5041 PyThreadState* __tstate = wxPyBeginAllowThreads();
5042 result = (wxIcon *)new wxIcon();
5043
5044 wxPyEndAllowThreads(__tstate);
5045 if (PyErr_Occurred()) SWIG_fail;
5046 }
5047 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5048 return resultobj;
5049 fail:
5050 return NULL;
5051 }
5052
5053
5054 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5055 PyObject *resultobj;
5056 wxIconLocation *arg1 = 0 ;
5057 wxIcon *result;
5058 PyObject * obj0 = 0 ;
5059 char *kwnames[] = {
5060 (char *) "loc", NULL
5061 };
5062
5063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5064 {
5065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5066 if (SWIG_arg_fail(1)) SWIG_fail;
5067 if (arg1 == NULL) {
5068 SWIG_null_ref("wxIconLocation");
5069 }
5070 if (SWIG_arg_fail(1)) SWIG_fail;
5071 }
5072 {
5073 if (!wxPyCheckForApp()) SWIG_fail;
5074 PyThreadState* __tstate = wxPyBeginAllowThreads();
5075 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5076
5077 wxPyEndAllowThreads(__tstate);
5078 if (PyErr_Occurred()) SWIG_fail;
5079 }
5080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5081 return resultobj;
5082 fail:
5083 return NULL;
5084 }
5085
5086
5087 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5088 PyObject *resultobj;
5089 wxBitmap *arg1 = 0 ;
5090 wxIcon *result;
5091 PyObject * obj0 = 0 ;
5092 char *kwnames[] = {
5093 (char *) "bmp", NULL
5094 };
5095
5096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5097 {
5098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5099 if (SWIG_arg_fail(1)) SWIG_fail;
5100 if (arg1 == NULL) {
5101 SWIG_null_ref("wxBitmap");
5102 }
5103 if (SWIG_arg_fail(1)) SWIG_fail;
5104 }
5105 {
5106 if (!wxPyCheckForApp()) SWIG_fail;
5107 PyThreadState* __tstate = wxPyBeginAllowThreads();
5108 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5109
5110 wxPyEndAllowThreads(__tstate);
5111 if (PyErr_Occurred()) SWIG_fail;
5112 }
5113 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5114 return resultobj;
5115 fail:
5116 return NULL;
5117 }
5118
5119
5120 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5121 PyObject *resultobj;
5122 PyObject *arg1 = (PyObject *) 0 ;
5123 wxIcon *result;
5124 PyObject * obj0 = 0 ;
5125 char *kwnames[] = {
5126 (char *) "listOfStrings", NULL
5127 };
5128
5129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5130 arg1 = obj0;
5131 {
5132 if (!wxPyCheckForApp()) SWIG_fail;
5133 PyThreadState* __tstate = wxPyBeginAllowThreads();
5134 result = (wxIcon *)new_wxIcon(arg1);
5135
5136 wxPyEndAllowThreads(__tstate);
5137 if (PyErr_Occurred()) SWIG_fail;
5138 }
5139 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5140 return resultobj;
5141 fail:
5142 return NULL;
5143 }
5144
5145
5146 static PyObject *_wrap_Icon_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
5147 PyObject *resultobj;
5148 wxIcon *arg1 = (wxIcon *) 0 ;
5149 wxString *arg2 = 0 ;
5150 wxBitmapType arg3 ;
5151 bool result;
5152 bool temp2 = false ;
5153 PyObject * obj0 = 0 ;
5154 PyObject * obj1 = 0 ;
5155 PyObject * obj2 = 0 ;
5156 char *kwnames[] = {
5157 (char *) "self",(char *) "name",(char *) "type", NULL
5158 };
5159
5160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Icon_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5162 if (SWIG_arg_fail(1)) SWIG_fail;
5163 {
5164 arg2 = wxString_in_helper(obj1);
5165 if (arg2 == NULL) SWIG_fail;
5166 temp2 = true;
5167 }
5168 {
5169 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
5170 if (SWIG_arg_fail(3)) SWIG_fail;
5171 }
5172 {
5173 PyThreadState* __tstate = wxPyBeginAllowThreads();
5174 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
5175
5176 wxPyEndAllowThreads(__tstate);
5177 if (PyErr_Occurred()) SWIG_fail;
5178 }
5179 {
5180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5181 }
5182 {
5183 if (temp2)
5184 delete arg2;
5185 }
5186 return resultobj;
5187 fail:
5188 {
5189 if (temp2)
5190 delete arg2;
5191 }
5192 return NULL;
5193 }
5194
5195
5196 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5197 PyObject *resultobj;
5198 wxIcon *arg1 = (wxIcon *) 0 ;
5199 bool result;
5200 PyObject * obj0 = 0 ;
5201 char *kwnames[] = {
5202 (char *) "self", NULL
5203 };
5204
5205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5207 if (SWIG_arg_fail(1)) SWIG_fail;
5208 {
5209 PyThreadState* __tstate = wxPyBeginAllowThreads();
5210 result = (bool)(arg1)->Ok();
5211
5212 wxPyEndAllowThreads(__tstate);
5213 if (PyErr_Occurred()) SWIG_fail;
5214 }
5215 {
5216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5217 }
5218 return resultobj;
5219 fail:
5220 return NULL;
5221 }
5222
5223
5224 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5225 PyObject *resultobj;
5226 wxIcon *arg1 = (wxIcon *) 0 ;
5227 int result;
5228 PyObject * obj0 = 0 ;
5229 char *kwnames[] = {
5230 (char *) "self", NULL
5231 };
5232
5233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5235 if (SWIG_arg_fail(1)) SWIG_fail;
5236 {
5237 PyThreadState* __tstate = wxPyBeginAllowThreads();
5238 result = (int)(arg1)->GetWidth();
5239
5240 wxPyEndAllowThreads(__tstate);
5241 if (PyErr_Occurred()) SWIG_fail;
5242 }
5243 {
5244 resultobj = SWIG_From_int((int)(result));
5245 }
5246 return resultobj;
5247 fail:
5248 return NULL;
5249 }
5250
5251
5252 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5253 PyObject *resultobj;
5254 wxIcon *arg1 = (wxIcon *) 0 ;
5255 int result;
5256 PyObject * obj0 = 0 ;
5257 char *kwnames[] = {
5258 (char *) "self", NULL
5259 };
5260
5261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5263 if (SWIG_arg_fail(1)) SWIG_fail;
5264 {
5265 PyThreadState* __tstate = wxPyBeginAllowThreads();
5266 result = (int)(arg1)->GetHeight();
5267
5268 wxPyEndAllowThreads(__tstate);
5269 if (PyErr_Occurred()) SWIG_fail;
5270 }
5271 {
5272 resultobj = SWIG_From_int((int)(result));
5273 }
5274 return resultobj;
5275 fail:
5276 return NULL;
5277 }
5278
5279
5280 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5281 PyObject *resultobj;
5282 wxIcon *arg1 = (wxIcon *) 0 ;
5283 int result;
5284 PyObject * obj0 = 0 ;
5285 char *kwnames[] = {
5286 (char *) "self", NULL
5287 };
5288
5289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5291 if (SWIG_arg_fail(1)) SWIG_fail;
5292 {
5293 PyThreadState* __tstate = wxPyBeginAllowThreads();
5294 result = (int)(arg1)->GetDepth();
5295
5296 wxPyEndAllowThreads(__tstate);
5297 if (PyErr_Occurred()) SWIG_fail;
5298 }
5299 {
5300 resultobj = SWIG_From_int((int)(result));
5301 }
5302 return resultobj;
5303 fail:
5304 return NULL;
5305 }
5306
5307
5308 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5309 PyObject *resultobj;
5310 wxIcon *arg1 = (wxIcon *) 0 ;
5311 int arg2 ;
5312 PyObject * obj0 = 0 ;
5313 PyObject * obj1 = 0 ;
5314 char *kwnames[] = {
5315 (char *) "self",(char *) "w", NULL
5316 };
5317
5318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5320 if (SWIG_arg_fail(1)) SWIG_fail;
5321 {
5322 arg2 = (int)(SWIG_As_int(obj1));
5323 if (SWIG_arg_fail(2)) SWIG_fail;
5324 }
5325 {
5326 PyThreadState* __tstate = wxPyBeginAllowThreads();
5327 (arg1)->SetWidth(arg2);
5328
5329 wxPyEndAllowThreads(__tstate);
5330 if (PyErr_Occurred()) SWIG_fail;
5331 }
5332 Py_INCREF(Py_None); resultobj = Py_None;
5333 return resultobj;
5334 fail:
5335 return NULL;
5336 }
5337
5338
5339 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5340 PyObject *resultobj;
5341 wxIcon *arg1 = (wxIcon *) 0 ;
5342 int arg2 ;
5343 PyObject * obj0 = 0 ;
5344 PyObject * obj1 = 0 ;
5345 char *kwnames[] = {
5346 (char *) "self",(char *) "h", NULL
5347 };
5348
5349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5351 if (SWIG_arg_fail(1)) SWIG_fail;
5352 {
5353 arg2 = (int)(SWIG_As_int(obj1));
5354 if (SWIG_arg_fail(2)) SWIG_fail;
5355 }
5356 {
5357 PyThreadState* __tstate = wxPyBeginAllowThreads();
5358 (arg1)->SetHeight(arg2);
5359
5360 wxPyEndAllowThreads(__tstate);
5361 if (PyErr_Occurred()) SWIG_fail;
5362 }
5363 Py_INCREF(Py_None); resultobj = Py_None;
5364 return resultobj;
5365 fail:
5366 return NULL;
5367 }
5368
5369
5370 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5371 PyObject *resultobj;
5372 wxIcon *arg1 = (wxIcon *) 0 ;
5373 int arg2 ;
5374 PyObject * obj0 = 0 ;
5375 PyObject * obj1 = 0 ;
5376 char *kwnames[] = {
5377 (char *) "self",(char *) "d", NULL
5378 };
5379
5380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5382 if (SWIG_arg_fail(1)) SWIG_fail;
5383 {
5384 arg2 = (int)(SWIG_As_int(obj1));
5385 if (SWIG_arg_fail(2)) SWIG_fail;
5386 }
5387 {
5388 PyThreadState* __tstate = wxPyBeginAllowThreads();
5389 (arg1)->SetDepth(arg2);
5390
5391 wxPyEndAllowThreads(__tstate);
5392 if (PyErr_Occurred()) SWIG_fail;
5393 }
5394 Py_INCREF(Py_None); resultobj = Py_None;
5395 return resultobj;
5396 fail:
5397 return NULL;
5398 }
5399
5400
5401 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5402 PyObject *resultobj;
5403 wxIcon *arg1 = (wxIcon *) 0 ;
5404 wxBitmap *arg2 = 0 ;
5405 PyObject * obj0 = 0 ;
5406 PyObject * obj1 = 0 ;
5407 char *kwnames[] = {
5408 (char *) "self",(char *) "bmp", NULL
5409 };
5410
5411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5413 if (SWIG_arg_fail(1)) SWIG_fail;
5414 {
5415 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5416 if (SWIG_arg_fail(2)) SWIG_fail;
5417 if (arg2 == NULL) {
5418 SWIG_null_ref("wxBitmap");
5419 }
5420 if (SWIG_arg_fail(2)) SWIG_fail;
5421 }
5422 {
5423 PyThreadState* __tstate = wxPyBeginAllowThreads();
5424 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5425
5426 wxPyEndAllowThreads(__tstate);
5427 if (PyErr_Occurred()) SWIG_fail;
5428 }
5429 Py_INCREF(Py_None); resultobj = Py_None;
5430 return resultobj;
5431 fail:
5432 return NULL;
5433 }
5434
5435
5436 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5437 PyObject *obj;
5438 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5439 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5440 Py_INCREF(obj);
5441 return Py_BuildValue((char *)"");
5442 }
5443 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5444 PyObject *resultobj;
5445 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5446 int arg2 = (int) 0 ;
5447 wxIconLocation *result;
5448 bool temp1 = false ;
5449 PyObject * obj0 = 0 ;
5450 PyObject * obj1 = 0 ;
5451 char *kwnames[] = {
5452 (char *) "filename",(char *) "num", NULL
5453 };
5454
5455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5456 if (obj0) {
5457 {
5458 arg1 = wxString_in_helper(obj0);
5459 if (arg1 == NULL) SWIG_fail;
5460 temp1 = true;
5461 }
5462 }
5463 if (obj1) {
5464 {
5465 arg2 = (int)(SWIG_As_int(obj1));
5466 if (SWIG_arg_fail(2)) SWIG_fail;
5467 }
5468 }
5469 {
5470 PyThreadState* __tstate = wxPyBeginAllowThreads();
5471 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5472
5473 wxPyEndAllowThreads(__tstate);
5474 if (PyErr_Occurred()) SWIG_fail;
5475 }
5476 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5477 {
5478 if (temp1)
5479 delete arg1;
5480 }
5481 return resultobj;
5482 fail:
5483 {
5484 if (temp1)
5485 delete arg1;
5486 }
5487 return NULL;
5488 }
5489
5490
5491 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5492 PyObject *resultobj;
5493 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5494 PyObject * obj0 = 0 ;
5495 char *kwnames[] = {
5496 (char *) "self", NULL
5497 };
5498
5499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5501 if (SWIG_arg_fail(1)) SWIG_fail;
5502 {
5503 PyThreadState* __tstate = wxPyBeginAllowThreads();
5504 delete arg1;
5505
5506 wxPyEndAllowThreads(__tstate);
5507 if (PyErr_Occurred()) SWIG_fail;
5508 }
5509 Py_INCREF(Py_None); resultobj = Py_None;
5510 return resultobj;
5511 fail:
5512 return NULL;
5513 }
5514
5515
5516 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5517 PyObject *resultobj;
5518 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5519 bool result;
5520 PyObject * obj0 = 0 ;
5521 char *kwnames[] = {
5522 (char *) "self", NULL
5523 };
5524
5525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5527 if (SWIG_arg_fail(1)) SWIG_fail;
5528 {
5529 PyThreadState* __tstate = wxPyBeginAllowThreads();
5530 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5531
5532 wxPyEndAllowThreads(__tstate);
5533 if (PyErr_Occurred()) SWIG_fail;
5534 }
5535 {
5536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5537 }
5538 return resultobj;
5539 fail:
5540 return NULL;
5541 }
5542
5543
5544 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5545 PyObject *resultobj;
5546 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5547 wxString *arg2 = 0 ;
5548 bool temp2 = false ;
5549 PyObject * obj0 = 0 ;
5550 PyObject * obj1 = 0 ;
5551 char *kwnames[] = {
5552 (char *) "self",(char *) "filename", NULL
5553 };
5554
5555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5557 if (SWIG_arg_fail(1)) SWIG_fail;
5558 {
5559 arg2 = wxString_in_helper(obj1);
5560 if (arg2 == NULL) SWIG_fail;
5561 temp2 = true;
5562 }
5563 {
5564 PyThreadState* __tstate = wxPyBeginAllowThreads();
5565 (arg1)->SetFileName((wxString const &)*arg2);
5566
5567 wxPyEndAllowThreads(__tstate);
5568 if (PyErr_Occurred()) SWIG_fail;
5569 }
5570 Py_INCREF(Py_None); resultobj = Py_None;
5571 {
5572 if (temp2)
5573 delete arg2;
5574 }
5575 return resultobj;
5576 fail:
5577 {
5578 if (temp2)
5579 delete arg2;
5580 }
5581 return NULL;
5582 }
5583
5584
5585 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5586 PyObject *resultobj;
5587 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5588 wxString *result;
5589 PyObject * obj0 = 0 ;
5590 char *kwnames[] = {
5591 (char *) "self", NULL
5592 };
5593
5594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5596 if (SWIG_arg_fail(1)) SWIG_fail;
5597 {
5598 PyThreadState* __tstate = wxPyBeginAllowThreads();
5599 {
5600 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5601 result = (wxString *) &_result_ref;
5602 }
5603
5604 wxPyEndAllowThreads(__tstate);
5605 if (PyErr_Occurred()) SWIG_fail;
5606 }
5607 {
5608 #if wxUSE_UNICODE
5609 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5610 #else
5611 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5612 #endif
5613 }
5614 return resultobj;
5615 fail:
5616 return NULL;
5617 }
5618
5619
5620 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5621 PyObject *resultobj;
5622 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5623 int arg2 ;
5624 PyObject * obj0 = 0 ;
5625 PyObject * obj1 = 0 ;
5626 char *kwnames[] = {
5627 (char *) "self",(char *) "num", NULL
5628 };
5629
5630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5632 if (SWIG_arg_fail(1)) SWIG_fail;
5633 {
5634 arg2 = (int)(SWIG_As_int(obj1));
5635 if (SWIG_arg_fail(2)) SWIG_fail;
5636 }
5637 {
5638 PyThreadState* __tstate = wxPyBeginAllowThreads();
5639 wxIconLocation_SetIndex(arg1,arg2);
5640
5641 wxPyEndAllowThreads(__tstate);
5642 if (PyErr_Occurred()) SWIG_fail;
5643 }
5644 Py_INCREF(Py_None); resultobj = Py_None;
5645 return resultobj;
5646 fail:
5647 return NULL;
5648 }
5649
5650
5651 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5652 PyObject *resultobj;
5653 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5654 int result;
5655 PyObject * obj0 = 0 ;
5656 char *kwnames[] = {
5657 (char *) "self", NULL
5658 };
5659
5660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5662 if (SWIG_arg_fail(1)) SWIG_fail;
5663 {
5664 PyThreadState* __tstate = wxPyBeginAllowThreads();
5665 result = (int)wxIconLocation_GetIndex(arg1);
5666
5667 wxPyEndAllowThreads(__tstate);
5668 if (PyErr_Occurred()) SWIG_fail;
5669 }
5670 {
5671 resultobj = SWIG_From_int((int)(result));
5672 }
5673 return resultobj;
5674 fail:
5675 return NULL;
5676 }
5677
5678
5679 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5680 PyObject *obj;
5681 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5682 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5683 Py_INCREF(obj);
5684 return Py_BuildValue((char *)"");
5685 }
5686 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5687 PyObject *resultobj;
5688 wxIconBundle *result;
5689 char *kwnames[] = {
5690 NULL
5691 };
5692
5693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5694 {
5695 PyThreadState* __tstate = wxPyBeginAllowThreads();
5696 result = (wxIconBundle *)new wxIconBundle();
5697
5698 wxPyEndAllowThreads(__tstate);
5699 if (PyErr_Occurred()) SWIG_fail;
5700 }
5701 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5702 return resultobj;
5703 fail:
5704 return NULL;
5705 }
5706
5707
5708 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5709 PyObject *resultobj;
5710 wxString *arg1 = 0 ;
5711 long arg2 ;
5712 wxIconBundle *result;
5713 bool temp1 = false ;
5714 PyObject * obj0 = 0 ;
5715 PyObject * obj1 = 0 ;
5716 char *kwnames[] = {
5717 (char *) "file",(char *) "type", NULL
5718 };
5719
5720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
5721 {
5722 arg1 = wxString_in_helper(obj0);
5723 if (arg1 == NULL) SWIG_fail;
5724 temp1 = true;
5725 }
5726 {
5727 arg2 = (long)(SWIG_As_long(obj1));
5728 if (SWIG_arg_fail(2)) SWIG_fail;
5729 }
5730 {
5731 PyThreadState* __tstate = wxPyBeginAllowThreads();
5732 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
5733
5734 wxPyEndAllowThreads(__tstate);
5735 if (PyErr_Occurred()) SWIG_fail;
5736 }
5737 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5738 {
5739 if (temp1)
5740 delete arg1;
5741 }
5742 return resultobj;
5743 fail:
5744 {
5745 if (temp1)
5746 delete arg1;
5747 }
5748 return NULL;
5749 }
5750
5751
5752 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5753 PyObject *resultobj;
5754 wxIcon *arg1 = 0 ;
5755 wxIconBundle *result;
5756 PyObject * obj0 = 0 ;
5757 char *kwnames[] = {
5758 (char *) "icon", NULL
5759 };
5760
5761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
5762 {
5763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5764 if (SWIG_arg_fail(1)) SWIG_fail;
5765 if (arg1 == NULL) {
5766 SWIG_null_ref("wxIcon");
5767 }
5768 if (SWIG_arg_fail(1)) SWIG_fail;
5769 }
5770 {
5771 PyThreadState* __tstate = wxPyBeginAllowThreads();
5772 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
5773
5774 wxPyEndAllowThreads(__tstate);
5775 if (PyErr_Occurred()) SWIG_fail;
5776 }
5777 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5778 return resultobj;
5779 fail:
5780 return NULL;
5781 }
5782
5783
5784 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5785 PyObject *resultobj;
5786 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5787 PyObject * obj0 = 0 ;
5788 char *kwnames[] = {
5789 (char *) "self", NULL
5790 };
5791
5792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
5793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5794 if (SWIG_arg_fail(1)) SWIG_fail;
5795 {
5796 PyThreadState* __tstate = wxPyBeginAllowThreads();
5797 delete arg1;
5798
5799 wxPyEndAllowThreads(__tstate);
5800 if (PyErr_Occurred()) SWIG_fail;
5801 }
5802 Py_INCREF(Py_None); resultobj = Py_None;
5803 return resultobj;
5804 fail:
5805 return NULL;
5806 }
5807
5808
5809 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5810 PyObject *resultobj;
5811 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5812 wxIcon *arg2 = 0 ;
5813 PyObject * obj0 = 0 ;
5814 PyObject * obj1 = 0 ;
5815 char *kwnames[] = {
5816 (char *) "self",(char *) "icon", NULL
5817 };
5818
5819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
5820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5821 if (SWIG_arg_fail(1)) SWIG_fail;
5822 {
5823 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5824 if (SWIG_arg_fail(2)) SWIG_fail;
5825 if (arg2 == NULL) {
5826 SWIG_null_ref("wxIcon");
5827 }
5828 if (SWIG_arg_fail(2)) SWIG_fail;
5829 }
5830 {
5831 PyThreadState* __tstate = wxPyBeginAllowThreads();
5832 (arg1)->AddIcon((wxIcon const &)*arg2);
5833
5834 wxPyEndAllowThreads(__tstate);
5835 if (PyErr_Occurred()) SWIG_fail;
5836 }
5837 Py_INCREF(Py_None); resultobj = Py_None;
5838 return resultobj;
5839 fail:
5840 return NULL;
5841 }
5842
5843
5844 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5845 PyObject *resultobj;
5846 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5847 wxString *arg2 = 0 ;
5848 long arg3 ;
5849 bool temp2 = false ;
5850 PyObject * obj0 = 0 ;
5851 PyObject * obj1 = 0 ;
5852 PyObject * obj2 = 0 ;
5853 char *kwnames[] = {
5854 (char *) "self",(char *) "file",(char *) "type", NULL
5855 };
5856
5857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5859 if (SWIG_arg_fail(1)) SWIG_fail;
5860 {
5861 arg2 = wxString_in_helper(obj1);
5862 if (arg2 == NULL) SWIG_fail;
5863 temp2 = true;
5864 }
5865 {
5866 arg3 = (long)(SWIG_As_long(obj2));
5867 if (SWIG_arg_fail(3)) SWIG_fail;
5868 }
5869 {
5870 PyThreadState* __tstate = wxPyBeginAllowThreads();
5871 (arg1)->AddIcon((wxString const &)*arg2,arg3);
5872
5873 wxPyEndAllowThreads(__tstate);
5874 if (PyErr_Occurred()) SWIG_fail;
5875 }
5876 Py_INCREF(Py_None); resultobj = Py_None;
5877 {
5878 if (temp2)
5879 delete arg2;
5880 }
5881 return resultobj;
5882 fail:
5883 {
5884 if (temp2)
5885 delete arg2;
5886 }
5887 return NULL;
5888 }
5889
5890
5891 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5892 PyObject *resultobj;
5893 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5894 wxSize *arg2 = 0 ;
5895 wxIcon *result;
5896 wxSize temp2 ;
5897 PyObject * obj0 = 0 ;
5898 PyObject * obj1 = 0 ;
5899 char *kwnames[] = {
5900 (char *) "self",(char *) "size", NULL
5901 };
5902
5903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
5904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5905 if (SWIG_arg_fail(1)) SWIG_fail;
5906 {
5907 arg2 = &temp2;
5908 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5909 }
5910 {
5911 PyThreadState* __tstate = wxPyBeginAllowThreads();
5912 {
5913 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
5914 result = (wxIcon *) &_result_ref;
5915 }
5916
5917 wxPyEndAllowThreads(__tstate);
5918 if (PyErr_Occurred()) SWIG_fail;
5919 }
5920 {
5921 wxIcon* resultptr = new wxIcon(*result);
5922 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
5923 }
5924 return resultobj;
5925 fail:
5926 return NULL;
5927 }
5928
5929
5930 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
5931 PyObject *obj;
5932 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5933 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
5934 Py_INCREF(obj);
5935 return Py_BuildValue((char *)"");
5936 }
5937 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5938 PyObject *resultobj;
5939 wxString *arg1 = 0 ;
5940 long arg2 ;
5941 int arg3 = (int) 0 ;
5942 int arg4 = (int) 0 ;
5943 wxCursor *result;
5944 bool temp1 = false ;
5945 PyObject * obj0 = 0 ;
5946 PyObject * obj1 = 0 ;
5947 PyObject * obj2 = 0 ;
5948 PyObject * obj3 = 0 ;
5949 char *kwnames[] = {
5950 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
5951 };
5952
5953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5954 {
5955 arg1 = wxString_in_helper(obj0);
5956 if (arg1 == NULL) SWIG_fail;
5957 temp1 = true;
5958 }
5959 {
5960 arg2 = (long)(SWIG_As_long(obj1));
5961 if (SWIG_arg_fail(2)) SWIG_fail;
5962 }
5963 if (obj2) {
5964 {
5965 arg3 = (int)(SWIG_As_int(obj2));
5966 if (SWIG_arg_fail(3)) SWIG_fail;
5967 }
5968 }
5969 if (obj3) {
5970 {
5971 arg4 = (int)(SWIG_As_int(obj3));
5972 if (SWIG_arg_fail(4)) SWIG_fail;
5973 }
5974 }
5975 {
5976 if (!wxPyCheckForApp()) SWIG_fail;
5977 PyThreadState* __tstate = wxPyBeginAllowThreads();
5978 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
5979
5980 wxPyEndAllowThreads(__tstate);
5981 if (PyErr_Occurred()) SWIG_fail;
5982 }
5983 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
5984 {
5985 if (temp1)
5986 delete arg1;
5987 }
5988 return resultobj;
5989 fail:
5990 {
5991 if (temp1)
5992 delete arg1;
5993 }
5994 return NULL;
5995 }
5996
5997
5998 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5999 PyObject *resultobj;
6000 wxCursor *arg1 = (wxCursor *) 0 ;
6001 PyObject * obj0 = 0 ;
6002 char *kwnames[] = {
6003 (char *) "self", NULL
6004 };
6005
6006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
6007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6008 if (SWIG_arg_fail(1)) SWIG_fail;
6009 {
6010 PyThreadState* __tstate = wxPyBeginAllowThreads();
6011 delete arg1;
6012
6013 wxPyEndAllowThreads(__tstate);
6014 if (PyErr_Occurred()) SWIG_fail;
6015 }
6016 Py_INCREF(Py_None); resultobj = Py_None;
6017 return resultobj;
6018 fail:
6019 return NULL;
6020 }
6021
6022
6023 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6024 PyObject *resultobj;
6025 int arg1 ;
6026 wxCursor *result;
6027 PyObject * obj0 = 0 ;
6028 char *kwnames[] = {
6029 (char *) "id", NULL
6030 };
6031
6032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
6033 {
6034 arg1 = (int)(SWIG_As_int(obj0));
6035 if (SWIG_arg_fail(1)) SWIG_fail;
6036 }
6037 {
6038 if (!wxPyCheckForApp()) SWIG_fail;
6039 PyThreadState* __tstate = wxPyBeginAllowThreads();
6040 result = (wxCursor *)new wxCursor(arg1);
6041
6042 wxPyEndAllowThreads(__tstate);
6043 if (PyErr_Occurred()) SWIG_fail;
6044 }
6045 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6046 return resultobj;
6047 fail:
6048 return NULL;
6049 }
6050
6051
6052 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6053 PyObject *resultobj;
6054 wxImage *arg1 = 0 ;
6055 wxCursor *result;
6056 PyObject * obj0 = 0 ;
6057 char *kwnames[] = {
6058 (char *) "image", NULL
6059 };
6060
6061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6062 {
6063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6064 if (SWIG_arg_fail(1)) SWIG_fail;
6065 if (arg1 == NULL) {
6066 SWIG_null_ref("wxImage");
6067 }
6068 if (SWIG_arg_fail(1)) SWIG_fail;
6069 }
6070 {
6071 if (!wxPyCheckForApp()) SWIG_fail;
6072 PyThreadState* __tstate = wxPyBeginAllowThreads();
6073 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6074
6075 wxPyEndAllowThreads(__tstate);
6076 if (PyErr_Occurred()) SWIG_fail;
6077 }
6078 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6079 return resultobj;
6080 fail:
6081 return NULL;
6082 }
6083
6084
6085 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6086 PyObject *resultobj;
6087 wxCursor *arg1 = (wxCursor *) 0 ;
6088 bool result;
6089 PyObject * obj0 = 0 ;
6090 char *kwnames[] = {
6091 (char *) "self", NULL
6092 };
6093
6094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6096 if (SWIG_arg_fail(1)) SWIG_fail;
6097 {
6098 PyThreadState* __tstate = wxPyBeginAllowThreads();
6099 result = (bool)(arg1)->Ok();
6100
6101 wxPyEndAllowThreads(__tstate);
6102 if (PyErr_Occurred()) SWIG_fail;
6103 }
6104 {
6105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6106 }
6107 return resultobj;
6108 fail:
6109 return NULL;
6110 }
6111
6112
6113 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6114 PyObject *obj;
6115 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6116 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6117 Py_INCREF(obj);
6118 return Py_BuildValue((char *)"");
6119 }
6120 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6121 PyObject *resultobj;
6122 int arg1 = (int) 0 ;
6123 int arg2 = (int) 0 ;
6124 int arg3 = (int) 0 ;
6125 int arg4 = (int) 0 ;
6126 wxRegion *result;
6127 PyObject * obj0 = 0 ;
6128 PyObject * obj1 = 0 ;
6129 PyObject * obj2 = 0 ;
6130 PyObject * obj3 = 0 ;
6131 char *kwnames[] = {
6132 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6133 };
6134
6135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6136 if (obj0) {
6137 {
6138 arg1 = (int)(SWIG_As_int(obj0));
6139 if (SWIG_arg_fail(1)) SWIG_fail;
6140 }
6141 }
6142 if (obj1) {
6143 {
6144 arg2 = (int)(SWIG_As_int(obj1));
6145 if (SWIG_arg_fail(2)) SWIG_fail;
6146 }
6147 }
6148 if (obj2) {
6149 {
6150 arg3 = (int)(SWIG_As_int(obj2));
6151 if (SWIG_arg_fail(3)) SWIG_fail;
6152 }
6153 }
6154 if (obj3) {
6155 {
6156 arg4 = (int)(SWIG_As_int(obj3));
6157 if (SWIG_arg_fail(4)) SWIG_fail;
6158 }
6159 }
6160 {
6161 if (!wxPyCheckForApp()) SWIG_fail;
6162 PyThreadState* __tstate = wxPyBeginAllowThreads();
6163 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6164
6165 wxPyEndAllowThreads(__tstate);
6166 if (PyErr_Occurred()) SWIG_fail;
6167 }
6168 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6169 return resultobj;
6170 fail:
6171 return NULL;
6172 }
6173
6174
6175 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6176 PyObject *resultobj;
6177 wxBitmap *arg1 = 0 ;
6178 wxRegion *result;
6179 PyObject * obj0 = 0 ;
6180 char *kwnames[] = {
6181 (char *) "bmp", NULL
6182 };
6183
6184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6185 {
6186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6187 if (SWIG_arg_fail(1)) SWIG_fail;
6188 if (arg1 == NULL) {
6189 SWIG_null_ref("wxBitmap");
6190 }
6191 if (SWIG_arg_fail(1)) SWIG_fail;
6192 }
6193 {
6194 if (!wxPyCheckForApp()) SWIG_fail;
6195 PyThreadState* __tstate = wxPyBeginAllowThreads();
6196 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6197
6198 wxPyEndAllowThreads(__tstate);
6199 if (PyErr_Occurred()) SWIG_fail;
6200 }
6201 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6202 return resultobj;
6203 fail:
6204 return NULL;
6205 }
6206
6207
6208 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6209 PyObject *resultobj;
6210 wxBitmap *arg1 = 0 ;
6211 wxColour *arg2 = 0 ;
6212 int arg3 = (int) 0 ;
6213 wxRegion *result;
6214 wxColour temp2 ;
6215 PyObject * obj0 = 0 ;
6216 PyObject * obj1 = 0 ;
6217 PyObject * obj2 = 0 ;
6218 char *kwnames[] = {
6219 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6220 };
6221
6222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6223 {
6224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6225 if (SWIG_arg_fail(1)) SWIG_fail;
6226 if (arg1 == NULL) {
6227 SWIG_null_ref("wxBitmap");
6228 }
6229 if (SWIG_arg_fail(1)) SWIG_fail;
6230 }
6231 {
6232 arg2 = &temp2;
6233 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6234 }
6235 if (obj2) {
6236 {
6237 arg3 = (int)(SWIG_As_int(obj2));
6238 if (SWIG_arg_fail(3)) SWIG_fail;
6239 }
6240 }
6241 {
6242 if (!wxPyCheckForApp()) SWIG_fail;
6243 PyThreadState* __tstate = wxPyBeginAllowThreads();
6244 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6245
6246 wxPyEndAllowThreads(__tstate);
6247 if (PyErr_Occurred()) SWIG_fail;
6248 }
6249 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6250 return resultobj;
6251 fail:
6252 return NULL;
6253 }
6254
6255
6256 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6257 PyObject *resultobj;
6258 int arg1 ;
6259 wxPoint *arg2 = (wxPoint *) 0 ;
6260 int arg3 = (int) wxWINDING_RULE ;
6261 wxRegion *result;
6262 PyObject * obj0 = 0 ;
6263 PyObject * obj1 = 0 ;
6264 char *kwnames[] = {
6265 (char *) "points",(char *) "fillStyle", NULL
6266 };
6267
6268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6269 {
6270 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6271 if (arg2 == NULL) SWIG_fail;
6272 }
6273 if (obj1) {
6274 {
6275 arg3 = (int)(SWIG_As_int(obj1));
6276 if (SWIG_arg_fail(3)) SWIG_fail;
6277 }
6278 }
6279 {
6280 if (!wxPyCheckForApp()) SWIG_fail;
6281 PyThreadState* __tstate = wxPyBeginAllowThreads();
6282 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6283
6284 wxPyEndAllowThreads(__tstate);
6285 if (PyErr_Occurred()) SWIG_fail;
6286 }
6287 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6288 {
6289 if (arg2) delete [] arg2;
6290 }
6291 return resultobj;
6292 fail:
6293 {
6294 if (arg2) delete [] arg2;
6295 }
6296 return NULL;
6297 }
6298
6299
6300 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6301 PyObject *resultobj;
6302 wxRegion *arg1 = (wxRegion *) 0 ;
6303 PyObject * obj0 = 0 ;
6304 char *kwnames[] = {
6305 (char *) "self", NULL
6306 };
6307
6308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6310 if (SWIG_arg_fail(1)) SWIG_fail;
6311 {
6312 PyThreadState* __tstate = wxPyBeginAllowThreads();
6313 delete arg1;
6314
6315 wxPyEndAllowThreads(__tstate);
6316 if (PyErr_Occurred()) SWIG_fail;
6317 }
6318 Py_INCREF(Py_None); resultobj = Py_None;
6319 return resultobj;
6320 fail:
6321 return NULL;
6322 }
6323
6324
6325 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6326 PyObject *resultobj;
6327 wxRegion *arg1 = (wxRegion *) 0 ;
6328 PyObject * obj0 = 0 ;
6329 char *kwnames[] = {
6330 (char *) "self", NULL
6331 };
6332
6333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6335 if (SWIG_arg_fail(1)) SWIG_fail;
6336 {
6337 PyThreadState* __tstate = wxPyBeginAllowThreads();
6338 (arg1)->Clear();
6339
6340 wxPyEndAllowThreads(__tstate);
6341 if (PyErr_Occurred()) SWIG_fail;
6342 }
6343 Py_INCREF(Py_None); resultobj = Py_None;
6344 return resultobj;
6345 fail:
6346 return NULL;
6347 }
6348
6349
6350 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6351 PyObject *resultobj;
6352 wxRegion *arg1 = (wxRegion *) 0 ;
6353 int arg2 ;
6354 int arg3 ;
6355 bool result;
6356 PyObject * obj0 = 0 ;
6357 PyObject * obj1 = 0 ;
6358 PyObject * obj2 = 0 ;
6359 char *kwnames[] = {
6360 (char *) "self",(char *) "x",(char *) "y", NULL
6361 };
6362
6363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6365 if (SWIG_arg_fail(1)) SWIG_fail;
6366 {
6367 arg2 = (int)(SWIG_As_int(obj1));
6368 if (SWIG_arg_fail(2)) SWIG_fail;
6369 }
6370 {
6371 arg3 = (int)(SWIG_As_int(obj2));
6372 if (SWIG_arg_fail(3)) SWIG_fail;
6373 }
6374 {
6375 PyThreadState* __tstate = wxPyBeginAllowThreads();
6376 result = (bool)(arg1)->Offset(arg2,arg3);
6377
6378 wxPyEndAllowThreads(__tstate);
6379 if (PyErr_Occurred()) SWIG_fail;
6380 }
6381 {
6382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6383 }
6384 return resultobj;
6385 fail:
6386 return NULL;
6387 }
6388
6389
6390 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6391 PyObject *resultobj;
6392 wxRegion *arg1 = (wxRegion *) 0 ;
6393 int arg2 ;
6394 int arg3 ;
6395 wxRegionContain result;
6396 PyObject * obj0 = 0 ;
6397 PyObject * obj1 = 0 ;
6398 PyObject * obj2 = 0 ;
6399 char *kwnames[] = {
6400 (char *) "self",(char *) "x",(char *) "y", NULL
6401 };
6402
6403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6405 if (SWIG_arg_fail(1)) SWIG_fail;
6406 {
6407 arg2 = (int)(SWIG_As_int(obj1));
6408 if (SWIG_arg_fail(2)) SWIG_fail;
6409 }
6410 {
6411 arg3 = (int)(SWIG_As_int(obj2));
6412 if (SWIG_arg_fail(3)) SWIG_fail;
6413 }
6414 {
6415 PyThreadState* __tstate = wxPyBeginAllowThreads();
6416 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6417
6418 wxPyEndAllowThreads(__tstate);
6419 if (PyErr_Occurred()) SWIG_fail;
6420 }
6421 resultobj = SWIG_From_int((result));
6422 return resultobj;
6423 fail:
6424 return NULL;
6425 }
6426
6427
6428 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6429 PyObject *resultobj;
6430 wxRegion *arg1 = (wxRegion *) 0 ;
6431 wxPoint *arg2 = 0 ;
6432 wxRegionContain result;
6433 wxPoint temp2 ;
6434 PyObject * obj0 = 0 ;
6435 PyObject * obj1 = 0 ;
6436 char *kwnames[] = {
6437 (char *) "self",(char *) "pt", NULL
6438 };
6439
6440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6442 if (SWIG_arg_fail(1)) SWIG_fail;
6443 {
6444 arg2 = &temp2;
6445 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6446 }
6447 {
6448 PyThreadState* __tstate = wxPyBeginAllowThreads();
6449 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
6450
6451 wxPyEndAllowThreads(__tstate);
6452 if (PyErr_Occurred()) SWIG_fail;
6453 }
6454 resultobj = SWIG_From_int((result));
6455 return resultobj;
6456 fail:
6457 return NULL;
6458 }
6459
6460
6461 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
6462 PyObject *resultobj;
6463 wxRegion *arg1 = (wxRegion *) 0 ;
6464 wxRect *arg2 = 0 ;
6465 wxRegionContain result;
6466 wxRect temp2 ;
6467 PyObject * obj0 = 0 ;
6468 PyObject * obj1 = 0 ;
6469 char *kwnames[] = {
6470 (char *) "self",(char *) "rect", NULL
6471 };
6472
6473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
6474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6475 if (SWIG_arg_fail(1)) SWIG_fail;
6476 {
6477 arg2 = &temp2;
6478 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6479 }
6480 {
6481 PyThreadState* __tstate = wxPyBeginAllowThreads();
6482 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
6483
6484 wxPyEndAllowThreads(__tstate);
6485 if (PyErr_Occurred()) SWIG_fail;
6486 }
6487 resultobj = SWIG_From_int((result));
6488 return resultobj;
6489 fail:
6490 return NULL;
6491 }
6492
6493
6494 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
6495 PyObject *resultobj;
6496 wxRegion *arg1 = (wxRegion *) 0 ;
6497 int arg2 ;
6498 int arg3 ;
6499 int arg4 ;
6500 int arg5 ;
6501 wxRegionContain result;
6502 PyObject * obj0 = 0 ;
6503 PyObject * obj1 = 0 ;
6504 PyObject * obj2 = 0 ;
6505 PyObject * obj3 = 0 ;
6506 PyObject * obj4 = 0 ;
6507 char *kwnames[] = {
6508 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
6509 };
6510
6511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6513 if (SWIG_arg_fail(1)) SWIG_fail;
6514 {
6515 arg2 = (int)(SWIG_As_int(obj1));
6516 if (SWIG_arg_fail(2)) SWIG_fail;
6517 }
6518 {
6519 arg3 = (int)(SWIG_As_int(obj2));
6520 if (SWIG_arg_fail(3)) SWIG_fail;
6521 }
6522 {
6523 arg4 = (int)(SWIG_As_int(obj3));
6524 if (SWIG_arg_fail(4)) SWIG_fail;
6525 }
6526 {
6527 arg5 = (int)(SWIG_As_int(obj4));
6528 if (SWIG_arg_fail(5)) SWIG_fail;
6529 }
6530 {
6531 PyThreadState* __tstate = wxPyBeginAllowThreads();
6532 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
6533
6534 wxPyEndAllowThreads(__tstate);
6535 if (PyErr_Occurred()) SWIG_fail;
6536 }
6537 resultobj = SWIG_From_int((result));
6538 return resultobj;
6539 fail:
6540 return NULL;
6541 }
6542
6543
6544 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
6545 PyObject *resultobj;
6546 wxRegion *arg1 = (wxRegion *) 0 ;
6547 wxRect result;
6548 PyObject * obj0 = 0 ;
6549 char *kwnames[] = {
6550 (char *) "self", NULL
6551 };
6552
6553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
6554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6555 if (SWIG_arg_fail(1)) SWIG_fail;
6556 {
6557 PyThreadState* __tstate = wxPyBeginAllowThreads();
6558 result = (arg1)->GetBox();
6559
6560 wxPyEndAllowThreads(__tstate);
6561 if (PyErr_Occurred()) SWIG_fail;
6562 }
6563 {
6564 wxRect * resultptr;
6565 resultptr = new wxRect((wxRect &)(result));
6566 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6567 }
6568 return resultobj;
6569 fail:
6570 return NULL;
6571 }
6572
6573
6574 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
6575 PyObject *resultobj;
6576 wxRegion *arg1 = (wxRegion *) 0 ;
6577 int arg2 ;
6578 int arg3 ;
6579 int arg4 ;
6580 int arg5 ;
6581 bool result;
6582 PyObject * obj0 = 0 ;
6583 PyObject * obj1 = 0 ;
6584 PyObject * obj2 = 0 ;
6585 PyObject * obj3 = 0 ;
6586 PyObject * obj4 = 0 ;
6587 char *kwnames[] = {
6588 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6589 };
6590
6591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6593 if (SWIG_arg_fail(1)) SWIG_fail;
6594 {
6595 arg2 = (int)(SWIG_As_int(obj1));
6596 if (SWIG_arg_fail(2)) SWIG_fail;
6597 }
6598 {
6599 arg3 = (int)(SWIG_As_int(obj2));
6600 if (SWIG_arg_fail(3)) SWIG_fail;
6601 }
6602 {
6603 arg4 = (int)(SWIG_As_int(obj3));
6604 if (SWIG_arg_fail(4)) SWIG_fail;
6605 }
6606 {
6607 arg5 = (int)(SWIG_As_int(obj4));
6608 if (SWIG_arg_fail(5)) SWIG_fail;
6609 }
6610 {
6611 PyThreadState* __tstate = wxPyBeginAllowThreads();
6612 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
6613
6614 wxPyEndAllowThreads(__tstate);
6615 if (PyErr_Occurred()) SWIG_fail;
6616 }
6617 {
6618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6619 }
6620 return resultobj;
6621 fail:
6622 return NULL;
6623 }
6624
6625
6626 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6627 PyObject *resultobj;
6628 wxRegion *arg1 = (wxRegion *) 0 ;
6629 wxRect *arg2 = 0 ;
6630 bool result;
6631 wxRect temp2 ;
6632 PyObject * obj0 = 0 ;
6633 PyObject * obj1 = 0 ;
6634 char *kwnames[] = {
6635 (char *) "self",(char *) "rect", NULL
6636 };
6637
6638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6640 if (SWIG_arg_fail(1)) SWIG_fail;
6641 {
6642 arg2 = &temp2;
6643 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6644 }
6645 {
6646 PyThreadState* __tstate = wxPyBeginAllowThreads();
6647 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
6648
6649 wxPyEndAllowThreads(__tstate);
6650 if (PyErr_Occurred()) SWIG_fail;
6651 }
6652 {
6653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6654 }
6655 return resultobj;
6656 fail:
6657 return NULL;
6658 }
6659
6660
6661 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6662 PyObject *resultobj;
6663 wxRegion *arg1 = (wxRegion *) 0 ;
6664 wxRegion *arg2 = 0 ;
6665 bool result;
6666 PyObject * obj0 = 0 ;
6667 PyObject * obj1 = 0 ;
6668 char *kwnames[] = {
6669 (char *) "self",(char *) "region", NULL
6670 };
6671
6672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
6673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6674 if (SWIG_arg_fail(1)) SWIG_fail;
6675 {
6676 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6677 if (SWIG_arg_fail(2)) SWIG_fail;
6678 if (arg2 == NULL) {
6679 SWIG_null_ref("wxRegion");
6680 }
6681 if (SWIG_arg_fail(2)) SWIG_fail;
6682 }
6683 {
6684 PyThreadState* __tstate = wxPyBeginAllowThreads();
6685 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
6686
6687 wxPyEndAllowThreads(__tstate);
6688 if (PyErr_Occurred()) SWIG_fail;
6689 }
6690 {
6691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6692 }
6693 return resultobj;
6694 fail:
6695 return NULL;
6696 }
6697
6698
6699 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
6700 PyObject *resultobj;
6701 wxRegion *arg1 = (wxRegion *) 0 ;
6702 bool result;
6703 PyObject * obj0 = 0 ;
6704 char *kwnames[] = {
6705 (char *) "self", NULL
6706 };
6707
6708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
6709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6710 if (SWIG_arg_fail(1)) SWIG_fail;
6711 {
6712 PyThreadState* __tstate = wxPyBeginAllowThreads();
6713 result = (bool)(arg1)->IsEmpty();
6714
6715 wxPyEndAllowThreads(__tstate);
6716 if (PyErr_Occurred()) SWIG_fail;
6717 }
6718 {
6719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6720 }
6721 return resultobj;
6722 fail:
6723 return NULL;
6724 }
6725
6726
6727 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6728 PyObject *resultobj;
6729 wxRegion *arg1 = (wxRegion *) 0 ;
6730 int arg2 ;
6731 int arg3 ;
6732 int arg4 ;
6733 int arg5 ;
6734 bool result;
6735 PyObject * obj0 = 0 ;
6736 PyObject * obj1 = 0 ;
6737 PyObject * obj2 = 0 ;
6738 PyObject * obj3 = 0 ;
6739 PyObject * obj4 = 0 ;
6740 char *kwnames[] = {
6741 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6742 };
6743
6744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6746 if (SWIG_arg_fail(1)) SWIG_fail;
6747 {
6748 arg2 = (int)(SWIG_As_int(obj1));
6749 if (SWIG_arg_fail(2)) SWIG_fail;
6750 }
6751 {
6752 arg3 = (int)(SWIG_As_int(obj2));
6753 if (SWIG_arg_fail(3)) SWIG_fail;
6754 }
6755 {
6756 arg4 = (int)(SWIG_As_int(obj3));
6757 if (SWIG_arg_fail(4)) SWIG_fail;
6758 }
6759 {
6760 arg5 = (int)(SWIG_As_int(obj4));
6761 if (SWIG_arg_fail(5)) SWIG_fail;
6762 }
6763 {
6764 PyThreadState* __tstate = wxPyBeginAllowThreads();
6765 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
6766
6767 wxPyEndAllowThreads(__tstate);
6768 if (PyErr_Occurred()) SWIG_fail;
6769 }
6770 {
6771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6772 }
6773 return resultobj;
6774 fail:
6775 return NULL;
6776 }
6777
6778
6779 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
6780 PyObject *resultobj;
6781 wxRegion *arg1 = (wxRegion *) 0 ;
6782 wxRect *arg2 = 0 ;
6783 bool result;
6784 wxRect temp2 ;
6785 PyObject * obj0 = 0 ;
6786 PyObject * obj1 = 0 ;
6787 char *kwnames[] = {
6788 (char *) "self",(char *) "rect", NULL
6789 };
6790
6791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
6792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6793 if (SWIG_arg_fail(1)) SWIG_fail;
6794 {
6795 arg2 = &temp2;
6796 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6797 }
6798 {
6799 PyThreadState* __tstate = wxPyBeginAllowThreads();
6800 result = (bool)(arg1)->Union((wxRect const &)*arg2);
6801
6802 wxPyEndAllowThreads(__tstate);
6803 if (PyErr_Occurred()) SWIG_fail;
6804 }
6805 {
6806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6807 }
6808 return resultobj;
6809 fail:
6810 return NULL;
6811 }
6812
6813
6814 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6815 PyObject *resultobj;
6816 wxRegion *arg1 = (wxRegion *) 0 ;
6817 wxRegion *arg2 = 0 ;
6818 bool result;
6819 PyObject * obj0 = 0 ;
6820 PyObject * obj1 = 0 ;
6821 char *kwnames[] = {
6822 (char *) "self",(char *) "region", NULL
6823 };
6824
6825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
6826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6827 if (SWIG_arg_fail(1)) SWIG_fail;
6828 {
6829 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6830 if (SWIG_arg_fail(2)) SWIG_fail;
6831 if (arg2 == NULL) {
6832 SWIG_null_ref("wxRegion");
6833 }
6834 if (SWIG_arg_fail(2)) SWIG_fail;
6835 }
6836 {
6837 PyThreadState* __tstate = wxPyBeginAllowThreads();
6838 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
6839
6840 wxPyEndAllowThreads(__tstate);
6841 if (PyErr_Occurred()) SWIG_fail;
6842 }
6843 {
6844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6845 }
6846 return resultobj;
6847 fail:
6848 return NULL;
6849 }
6850
6851
6852 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
6853 PyObject *resultobj;
6854 wxRegion *arg1 = (wxRegion *) 0 ;
6855 int arg2 ;
6856 int arg3 ;
6857 int arg4 ;
6858 int arg5 ;
6859 bool result;
6860 PyObject * obj0 = 0 ;
6861 PyObject * obj1 = 0 ;
6862 PyObject * obj2 = 0 ;
6863 PyObject * obj3 = 0 ;
6864 PyObject * obj4 = 0 ;
6865 char *kwnames[] = {
6866 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6867 };
6868
6869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6871 if (SWIG_arg_fail(1)) SWIG_fail;
6872 {
6873 arg2 = (int)(SWIG_As_int(obj1));
6874 if (SWIG_arg_fail(2)) SWIG_fail;
6875 }
6876 {
6877 arg3 = (int)(SWIG_As_int(obj2));
6878 if (SWIG_arg_fail(3)) SWIG_fail;
6879 }
6880 {
6881 arg4 = (int)(SWIG_As_int(obj3));
6882 if (SWIG_arg_fail(4)) SWIG_fail;
6883 }
6884 {
6885 arg5 = (int)(SWIG_As_int(obj4));
6886 if (SWIG_arg_fail(5)) SWIG_fail;
6887 }
6888 {
6889 PyThreadState* __tstate = wxPyBeginAllowThreads();
6890 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
6891
6892 wxPyEndAllowThreads(__tstate);
6893 if (PyErr_Occurred()) SWIG_fail;
6894 }
6895 {
6896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6897 }
6898 return resultobj;
6899 fail:
6900 return NULL;
6901 }
6902
6903
6904 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
6905 PyObject *resultobj;
6906 wxRegion *arg1 = (wxRegion *) 0 ;
6907 wxRect *arg2 = 0 ;
6908 bool result;
6909 wxRect temp2 ;
6910 PyObject * obj0 = 0 ;
6911 PyObject * obj1 = 0 ;
6912 char *kwnames[] = {
6913 (char *) "self",(char *) "rect", NULL
6914 };
6915
6916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
6917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6918 if (SWIG_arg_fail(1)) SWIG_fail;
6919 {
6920 arg2 = &temp2;
6921 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6922 }
6923 {
6924 PyThreadState* __tstate = wxPyBeginAllowThreads();
6925 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
6926
6927 wxPyEndAllowThreads(__tstate);
6928 if (PyErr_Occurred()) SWIG_fail;
6929 }
6930 {
6931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6932 }
6933 return resultobj;
6934 fail:
6935 return NULL;
6936 }
6937
6938
6939 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6940 PyObject *resultobj;
6941 wxRegion *arg1 = (wxRegion *) 0 ;
6942 wxRegion *arg2 = 0 ;
6943 bool result;
6944 PyObject * obj0 = 0 ;
6945 PyObject * obj1 = 0 ;
6946 char *kwnames[] = {
6947 (char *) "self",(char *) "region", NULL
6948 };
6949
6950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
6951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6952 if (SWIG_arg_fail(1)) SWIG_fail;
6953 {
6954 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6955 if (SWIG_arg_fail(2)) SWIG_fail;
6956 if (arg2 == NULL) {
6957 SWIG_null_ref("wxRegion");
6958 }
6959 if (SWIG_arg_fail(2)) SWIG_fail;
6960 }
6961 {
6962 PyThreadState* __tstate = wxPyBeginAllowThreads();
6963 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
6964
6965 wxPyEndAllowThreads(__tstate);
6966 if (PyErr_Occurred()) SWIG_fail;
6967 }
6968 {
6969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6970 }
6971 return resultobj;
6972 fail:
6973 return NULL;
6974 }
6975
6976
6977 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
6978 PyObject *resultobj;
6979 wxRegion *arg1 = (wxRegion *) 0 ;
6980 int arg2 ;
6981 int arg3 ;
6982 int arg4 ;
6983 int arg5 ;
6984 bool result;
6985 PyObject * obj0 = 0 ;
6986 PyObject * obj1 = 0 ;
6987 PyObject * obj2 = 0 ;
6988 PyObject * obj3 = 0 ;
6989 PyObject * obj4 = 0 ;
6990 char *kwnames[] = {
6991 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6992 };
6993
6994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6996 if (SWIG_arg_fail(1)) SWIG_fail;
6997 {
6998 arg2 = (int)(SWIG_As_int(obj1));
6999 if (SWIG_arg_fail(2)) SWIG_fail;
7000 }
7001 {
7002 arg3 = (int)(SWIG_As_int(obj2));
7003 if (SWIG_arg_fail(3)) SWIG_fail;
7004 }
7005 {
7006 arg4 = (int)(SWIG_As_int(obj3));
7007 if (SWIG_arg_fail(4)) SWIG_fail;
7008 }
7009 {
7010 arg5 = (int)(SWIG_As_int(obj4));
7011 if (SWIG_arg_fail(5)) SWIG_fail;
7012 }
7013 {
7014 PyThreadState* __tstate = wxPyBeginAllowThreads();
7015 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
7016
7017 wxPyEndAllowThreads(__tstate);
7018 if (PyErr_Occurred()) SWIG_fail;
7019 }
7020 {
7021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7022 }
7023 return resultobj;
7024 fail:
7025 return NULL;
7026 }
7027
7028
7029 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
7030 PyObject *resultobj;
7031 wxRegion *arg1 = (wxRegion *) 0 ;
7032 wxRect *arg2 = 0 ;
7033 bool result;
7034 wxRect temp2 ;
7035 PyObject * obj0 = 0 ;
7036 PyObject * obj1 = 0 ;
7037 char *kwnames[] = {
7038 (char *) "self",(char *) "rect", NULL
7039 };
7040
7041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7043 if (SWIG_arg_fail(1)) SWIG_fail;
7044 {
7045 arg2 = &temp2;
7046 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7047 }
7048 {
7049 PyThreadState* __tstate = wxPyBeginAllowThreads();
7050 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7051
7052 wxPyEndAllowThreads(__tstate);
7053 if (PyErr_Occurred()) SWIG_fail;
7054 }
7055 {
7056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7057 }
7058 return resultobj;
7059 fail:
7060 return NULL;
7061 }
7062
7063
7064 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7065 PyObject *resultobj;
7066 wxRegion *arg1 = (wxRegion *) 0 ;
7067 wxRegion *arg2 = 0 ;
7068 bool result;
7069 PyObject * obj0 = 0 ;
7070 PyObject * obj1 = 0 ;
7071 char *kwnames[] = {
7072 (char *) "self",(char *) "region", NULL
7073 };
7074
7075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7077 if (SWIG_arg_fail(1)) SWIG_fail;
7078 {
7079 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7080 if (SWIG_arg_fail(2)) SWIG_fail;
7081 if (arg2 == NULL) {
7082 SWIG_null_ref("wxRegion");
7083 }
7084 if (SWIG_arg_fail(2)) SWIG_fail;
7085 }
7086 {
7087 PyThreadState* __tstate = wxPyBeginAllowThreads();
7088 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7089
7090 wxPyEndAllowThreads(__tstate);
7091 if (PyErr_Occurred()) SWIG_fail;
7092 }
7093 {
7094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7095 }
7096 return resultobj;
7097 fail:
7098 return NULL;
7099 }
7100
7101
7102 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7103 PyObject *resultobj;
7104 wxRegion *arg1 = (wxRegion *) 0 ;
7105 SwigValueWrapper<wxBitmap > result;
7106 PyObject * obj0 = 0 ;
7107 char *kwnames[] = {
7108 (char *) "self", NULL
7109 };
7110
7111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7113 if (SWIG_arg_fail(1)) SWIG_fail;
7114 {
7115 PyThreadState* __tstate = wxPyBeginAllowThreads();
7116 result = (arg1)->ConvertToBitmap();
7117
7118 wxPyEndAllowThreads(__tstate);
7119 if (PyErr_Occurred()) SWIG_fail;
7120 }
7121 {
7122 wxBitmap * resultptr;
7123 resultptr = new wxBitmap((wxBitmap &)(result));
7124 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7125 }
7126 return resultobj;
7127 fail:
7128 return NULL;
7129 }
7130
7131
7132 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7133 PyObject *resultobj;
7134 wxRegion *arg1 = (wxRegion *) 0 ;
7135 wxBitmap *arg2 = 0 ;
7136 bool result;
7137 PyObject * obj0 = 0 ;
7138 PyObject * obj1 = 0 ;
7139 char *kwnames[] = {
7140 (char *) "self",(char *) "bmp", NULL
7141 };
7142
7143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7145 if (SWIG_arg_fail(1)) SWIG_fail;
7146 {
7147 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7148 if (SWIG_arg_fail(2)) SWIG_fail;
7149 if (arg2 == NULL) {
7150 SWIG_null_ref("wxBitmap");
7151 }
7152 if (SWIG_arg_fail(2)) SWIG_fail;
7153 }
7154 {
7155 PyThreadState* __tstate = wxPyBeginAllowThreads();
7156 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7157
7158 wxPyEndAllowThreads(__tstate);
7159 if (PyErr_Occurred()) SWIG_fail;
7160 }
7161 {
7162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7163 }
7164 return resultobj;
7165 fail:
7166 return NULL;
7167 }
7168
7169
7170 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7171 PyObject *resultobj;
7172 wxRegion *arg1 = (wxRegion *) 0 ;
7173 wxBitmap *arg2 = 0 ;
7174 wxColour *arg3 = 0 ;
7175 int arg4 = (int) 0 ;
7176 bool result;
7177 wxColour temp3 ;
7178 PyObject * obj0 = 0 ;
7179 PyObject * obj1 = 0 ;
7180 PyObject * obj2 = 0 ;
7181 PyObject * obj3 = 0 ;
7182 char *kwnames[] = {
7183 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7184 };
7185
7186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7188 if (SWIG_arg_fail(1)) SWIG_fail;
7189 {
7190 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7191 if (SWIG_arg_fail(2)) SWIG_fail;
7192 if (arg2 == NULL) {
7193 SWIG_null_ref("wxBitmap");
7194 }
7195 if (SWIG_arg_fail(2)) SWIG_fail;
7196 }
7197 {
7198 arg3 = &temp3;
7199 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7200 }
7201 if (obj3) {
7202 {
7203 arg4 = (int)(SWIG_As_int(obj3));
7204 if (SWIG_arg_fail(4)) SWIG_fail;
7205 }
7206 }
7207 {
7208 PyThreadState* __tstate = wxPyBeginAllowThreads();
7209 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7210
7211 wxPyEndAllowThreads(__tstate);
7212 if (PyErr_Occurred()) SWIG_fail;
7213 }
7214 {
7215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7216 }
7217 return resultobj;
7218 fail:
7219 return NULL;
7220 }
7221
7222
7223 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7224 PyObject *obj;
7225 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7226 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7227 Py_INCREF(obj);
7228 return Py_BuildValue((char *)"");
7229 }
7230 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7231 PyObject *resultobj;
7232 wxRegion *arg1 = 0 ;
7233 wxRegionIterator *result;
7234 PyObject * obj0 = 0 ;
7235 char *kwnames[] = {
7236 (char *) "region", NULL
7237 };
7238
7239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7240 {
7241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7242 if (SWIG_arg_fail(1)) SWIG_fail;
7243 if (arg1 == NULL) {
7244 SWIG_null_ref("wxRegion");
7245 }
7246 if (SWIG_arg_fail(1)) SWIG_fail;
7247 }
7248 {
7249 if (!wxPyCheckForApp()) SWIG_fail;
7250 PyThreadState* __tstate = wxPyBeginAllowThreads();
7251 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7252
7253 wxPyEndAllowThreads(__tstate);
7254 if (PyErr_Occurred()) SWIG_fail;
7255 }
7256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7257 return resultobj;
7258 fail:
7259 return NULL;
7260 }
7261
7262
7263 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7264 PyObject *resultobj;
7265 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7266 PyObject * obj0 = 0 ;
7267 char *kwnames[] = {
7268 (char *) "self", NULL
7269 };
7270
7271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7273 if (SWIG_arg_fail(1)) SWIG_fail;
7274 {
7275 PyThreadState* __tstate = wxPyBeginAllowThreads();
7276 delete arg1;
7277
7278 wxPyEndAllowThreads(__tstate);
7279 if (PyErr_Occurred()) SWIG_fail;
7280 }
7281 Py_INCREF(Py_None); resultobj = Py_None;
7282 return resultobj;
7283 fail:
7284 return NULL;
7285 }
7286
7287
7288 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7289 PyObject *resultobj;
7290 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7291 int result;
7292 PyObject * obj0 = 0 ;
7293 char *kwnames[] = {
7294 (char *) "self", NULL
7295 };
7296
7297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7299 if (SWIG_arg_fail(1)) SWIG_fail;
7300 {
7301 PyThreadState* __tstate = wxPyBeginAllowThreads();
7302 result = (int)(arg1)->GetX();
7303
7304 wxPyEndAllowThreads(__tstate);
7305 if (PyErr_Occurred()) SWIG_fail;
7306 }
7307 {
7308 resultobj = SWIG_From_int((int)(result));
7309 }
7310 return resultobj;
7311 fail:
7312 return NULL;
7313 }
7314
7315
7316 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7317 PyObject *resultobj;
7318 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7319 int result;
7320 PyObject * obj0 = 0 ;
7321 char *kwnames[] = {
7322 (char *) "self", NULL
7323 };
7324
7325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7327 if (SWIG_arg_fail(1)) SWIG_fail;
7328 {
7329 PyThreadState* __tstate = wxPyBeginAllowThreads();
7330 result = (int)(arg1)->GetY();
7331
7332 wxPyEndAllowThreads(__tstate);
7333 if (PyErr_Occurred()) SWIG_fail;
7334 }
7335 {
7336 resultobj = SWIG_From_int((int)(result));
7337 }
7338 return resultobj;
7339 fail:
7340 return NULL;
7341 }
7342
7343
7344 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7345 PyObject *resultobj;
7346 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7347 int result;
7348 PyObject * obj0 = 0 ;
7349 char *kwnames[] = {
7350 (char *) "self", NULL
7351 };
7352
7353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7355 if (SWIG_arg_fail(1)) SWIG_fail;
7356 {
7357 PyThreadState* __tstate = wxPyBeginAllowThreads();
7358 result = (int)(arg1)->GetW();
7359
7360 wxPyEndAllowThreads(__tstate);
7361 if (PyErr_Occurred()) SWIG_fail;
7362 }
7363 {
7364 resultobj = SWIG_From_int((int)(result));
7365 }
7366 return resultobj;
7367 fail:
7368 return NULL;
7369 }
7370
7371
7372 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7373 PyObject *resultobj;
7374 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7375 int result;
7376 PyObject * obj0 = 0 ;
7377 char *kwnames[] = {
7378 (char *) "self", NULL
7379 };
7380
7381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7383 if (SWIG_arg_fail(1)) SWIG_fail;
7384 {
7385 PyThreadState* __tstate = wxPyBeginAllowThreads();
7386 result = (int)(arg1)->GetWidth();
7387
7388 wxPyEndAllowThreads(__tstate);
7389 if (PyErr_Occurred()) SWIG_fail;
7390 }
7391 {
7392 resultobj = SWIG_From_int((int)(result));
7393 }
7394 return resultobj;
7395 fail:
7396 return NULL;
7397 }
7398
7399
7400 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7401 PyObject *resultobj;
7402 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7403 int result;
7404 PyObject * obj0 = 0 ;
7405 char *kwnames[] = {
7406 (char *) "self", NULL
7407 };
7408
7409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7411 if (SWIG_arg_fail(1)) SWIG_fail;
7412 {
7413 PyThreadState* __tstate = wxPyBeginAllowThreads();
7414 result = (int)(arg1)->GetH();
7415
7416 wxPyEndAllowThreads(__tstate);
7417 if (PyErr_Occurred()) SWIG_fail;
7418 }
7419 {
7420 resultobj = SWIG_From_int((int)(result));
7421 }
7422 return resultobj;
7423 fail:
7424 return NULL;
7425 }
7426
7427
7428 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7429 PyObject *resultobj;
7430 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7431 int result;
7432 PyObject * obj0 = 0 ;
7433 char *kwnames[] = {
7434 (char *) "self", NULL
7435 };
7436
7437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7439 if (SWIG_arg_fail(1)) SWIG_fail;
7440 {
7441 PyThreadState* __tstate = wxPyBeginAllowThreads();
7442 result = (int)(arg1)->GetHeight();
7443
7444 wxPyEndAllowThreads(__tstate);
7445 if (PyErr_Occurred()) SWIG_fail;
7446 }
7447 {
7448 resultobj = SWIG_From_int((int)(result));
7449 }
7450 return resultobj;
7451 fail:
7452 return NULL;
7453 }
7454
7455
7456 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
7457 PyObject *resultobj;
7458 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7459 wxRect result;
7460 PyObject * obj0 = 0 ;
7461 char *kwnames[] = {
7462 (char *) "self", NULL
7463 };
7464
7465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
7466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7467 if (SWIG_arg_fail(1)) SWIG_fail;
7468 {
7469 PyThreadState* __tstate = wxPyBeginAllowThreads();
7470 result = (arg1)->GetRect();
7471
7472 wxPyEndAllowThreads(__tstate);
7473 if (PyErr_Occurred()) SWIG_fail;
7474 }
7475 {
7476 wxRect * resultptr;
7477 resultptr = new wxRect((wxRect &)(result));
7478 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7479 }
7480 return resultobj;
7481 fail:
7482 return NULL;
7483 }
7484
7485
7486 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
7487 PyObject *resultobj;
7488 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7489 bool result;
7490 PyObject * obj0 = 0 ;
7491 char *kwnames[] = {
7492 (char *) "self", NULL
7493 };
7494
7495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
7496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7497 if (SWIG_arg_fail(1)) SWIG_fail;
7498 {
7499 PyThreadState* __tstate = wxPyBeginAllowThreads();
7500 result = (bool)(arg1)->HaveRects();
7501
7502 wxPyEndAllowThreads(__tstate);
7503 if (PyErr_Occurred()) SWIG_fail;
7504 }
7505 {
7506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7507 }
7508 return resultobj;
7509 fail:
7510 return NULL;
7511 }
7512
7513
7514 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
7515 PyObject *resultobj;
7516 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7517 PyObject * obj0 = 0 ;
7518 char *kwnames[] = {
7519 (char *) "self", NULL
7520 };
7521
7522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
7523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7524 if (SWIG_arg_fail(1)) SWIG_fail;
7525 {
7526 PyThreadState* __tstate = wxPyBeginAllowThreads();
7527 (arg1)->Reset();
7528
7529 wxPyEndAllowThreads(__tstate);
7530 if (PyErr_Occurred()) SWIG_fail;
7531 }
7532 Py_INCREF(Py_None); resultobj = Py_None;
7533 return resultobj;
7534 fail:
7535 return NULL;
7536 }
7537
7538
7539 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
7540 PyObject *resultobj;
7541 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7542 PyObject * obj0 = 0 ;
7543 char *kwnames[] = {
7544 (char *) "self", NULL
7545 };
7546
7547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
7548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7549 if (SWIG_arg_fail(1)) SWIG_fail;
7550 {
7551 PyThreadState* __tstate = wxPyBeginAllowThreads();
7552 wxRegionIterator_Next(arg1);
7553
7554 wxPyEndAllowThreads(__tstate);
7555 if (PyErr_Occurred()) SWIG_fail;
7556 }
7557 Py_INCREF(Py_None); resultobj = Py_None;
7558 return resultobj;
7559 fail:
7560 return NULL;
7561 }
7562
7563
7564 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
7565 PyObject *resultobj;
7566 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7567 bool result;
7568 PyObject * obj0 = 0 ;
7569 char *kwnames[] = {
7570 (char *) "self", NULL
7571 };
7572
7573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
7574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7575 if (SWIG_arg_fail(1)) SWIG_fail;
7576 {
7577 PyThreadState* __tstate = wxPyBeginAllowThreads();
7578 result = (bool)wxRegionIterator___nonzero__(arg1);
7579
7580 wxPyEndAllowThreads(__tstate);
7581 if (PyErr_Occurred()) SWIG_fail;
7582 }
7583 {
7584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7585 }
7586 return resultobj;
7587 fail:
7588 return NULL;
7589 }
7590
7591
7592 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
7593 PyObject *obj;
7594 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7595 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
7596 Py_INCREF(obj);
7597 return Py_BuildValue((char *)"");
7598 }
7599 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7600 PyObject *resultobj;
7601 wxNativeFontInfo *result;
7602 char *kwnames[] = {
7603 NULL
7604 };
7605
7606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
7607 {
7608 PyThreadState* __tstate = wxPyBeginAllowThreads();
7609 result = (wxNativeFontInfo *)new wxNativeFontInfo();
7610
7611 wxPyEndAllowThreads(__tstate);
7612 if (PyErr_Occurred()) SWIG_fail;
7613 }
7614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
7615 return resultobj;
7616 fail:
7617 return NULL;
7618 }
7619
7620
7621 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7622 PyObject *resultobj;
7623 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7624 PyObject * obj0 = 0 ;
7625 char *kwnames[] = {
7626 (char *) "self", NULL
7627 };
7628
7629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
7630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7631 if (SWIG_arg_fail(1)) SWIG_fail;
7632 {
7633 PyThreadState* __tstate = wxPyBeginAllowThreads();
7634 delete arg1;
7635
7636 wxPyEndAllowThreads(__tstate);
7637 if (PyErr_Occurred()) SWIG_fail;
7638 }
7639 Py_INCREF(Py_None); resultobj = Py_None;
7640 return resultobj;
7641 fail:
7642 return NULL;
7643 }
7644
7645
7646 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
7647 PyObject *resultobj;
7648 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7649 PyObject * obj0 = 0 ;
7650 char *kwnames[] = {
7651 (char *) "self", NULL
7652 };
7653
7654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
7655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7656 if (SWIG_arg_fail(1)) SWIG_fail;
7657 {
7658 PyThreadState* __tstate = wxPyBeginAllowThreads();
7659 (arg1)->Init();
7660
7661 wxPyEndAllowThreads(__tstate);
7662 if (PyErr_Occurred()) SWIG_fail;
7663 }
7664 Py_INCREF(Py_None); resultobj = Py_None;
7665 return resultobj;
7666 fail:
7667 return NULL;
7668 }
7669
7670
7671 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
7672 PyObject *resultobj;
7673 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7674 wxFont *arg2 = 0 ;
7675 PyObject * obj0 = 0 ;
7676 PyObject * obj1 = 0 ;
7677 char *kwnames[] = {
7678 (char *) "self",(char *) "font", NULL
7679 };
7680
7681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
7682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7683 if (SWIG_arg_fail(1)) SWIG_fail;
7684 {
7685 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
7686 if (SWIG_arg_fail(2)) SWIG_fail;
7687 if (arg2 == NULL) {
7688 SWIG_null_ref("wxFont");
7689 }
7690 if (SWIG_arg_fail(2)) SWIG_fail;
7691 }
7692 {
7693 PyThreadState* __tstate = wxPyBeginAllowThreads();
7694 (arg1)->InitFromFont((wxFont const &)*arg2);
7695
7696 wxPyEndAllowThreads(__tstate);
7697 if (PyErr_Occurred()) SWIG_fail;
7698 }
7699 Py_INCREF(Py_None); resultobj = Py_None;
7700 return resultobj;
7701 fail:
7702 return NULL;
7703 }
7704
7705
7706 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7707 PyObject *resultobj;
7708 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7709 int result;
7710 PyObject * obj0 = 0 ;
7711 char *kwnames[] = {
7712 (char *) "self", NULL
7713 };
7714
7715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
7716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7717 if (SWIG_arg_fail(1)) SWIG_fail;
7718 {
7719 PyThreadState* __tstate = wxPyBeginAllowThreads();
7720 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
7721
7722 wxPyEndAllowThreads(__tstate);
7723 if (PyErr_Occurred()) SWIG_fail;
7724 }
7725 {
7726 resultobj = SWIG_From_int((int)(result));
7727 }
7728 return resultobj;
7729 fail:
7730 return NULL;
7731 }
7732
7733
7734 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7735 PyObject *resultobj;
7736 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7737 wxFontStyle result;
7738 PyObject * obj0 = 0 ;
7739 char *kwnames[] = {
7740 (char *) "self", NULL
7741 };
7742
7743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
7744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7745 if (SWIG_arg_fail(1)) SWIG_fail;
7746 {
7747 PyThreadState* __tstate = wxPyBeginAllowThreads();
7748 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
7749
7750 wxPyEndAllowThreads(__tstate);
7751 if (PyErr_Occurred()) SWIG_fail;
7752 }
7753 resultobj = SWIG_From_int((result));
7754 return resultobj;
7755 fail:
7756 return NULL;
7757 }
7758
7759
7760 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7761 PyObject *resultobj;
7762 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7763 wxFontWeight result;
7764 PyObject * obj0 = 0 ;
7765 char *kwnames[] = {
7766 (char *) "self", NULL
7767 };
7768
7769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
7770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7771 if (SWIG_arg_fail(1)) SWIG_fail;
7772 {
7773 PyThreadState* __tstate = wxPyBeginAllowThreads();
7774 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
7775
7776 wxPyEndAllowThreads(__tstate);
7777 if (PyErr_Occurred()) SWIG_fail;
7778 }
7779 resultobj = SWIG_From_int((result));
7780 return resultobj;
7781 fail:
7782 return NULL;
7783 }
7784
7785
7786 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7787 PyObject *resultobj;
7788 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7789 bool result;
7790 PyObject * obj0 = 0 ;
7791 char *kwnames[] = {
7792 (char *) "self", NULL
7793 };
7794
7795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
7796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7797 if (SWIG_arg_fail(1)) SWIG_fail;
7798 {
7799 PyThreadState* __tstate = wxPyBeginAllowThreads();
7800 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
7801
7802 wxPyEndAllowThreads(__tstate);
7803 if (PyErr_Occurred()) SWIG_fail;
7804 }
7805 {
7806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7807 }
7808 return resultobj;
7809 fail:
7810 return NULL;
7811 }
7812
7813
7814 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7815 PyObject *resultobj;
7816 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7817 wxString result;
7818 PyObject * obj0 = 0 ;
7819 char *kwnames[] = {
7820 (char *) "self", NULL
7821 };
7822
7823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
7824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7825 if (SWIG_arg_fail(1)) SWIG_fail;
7826 {
7827 PyThreadState* __tstate = wxPyBeginAllowThreads();
7828 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
7829
7830 wxPyEndAllowThreads(__tstate);
7831 if (PyErr_Occurred()) SWIG_fail;
7832 }
7833 {
7834 #if wxUSE_UNICODE
7835 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7836 #else
7837 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7838 #endif
7839 }
7840 return resultobj;
7841 fail:
7842 return NULL;
7843 }
7844
7845
7846 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
7847 PyObject *resultobj;
7848 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7849 wxFontFamily result;
7850 PyObject * obj0 = 0 ;
7851 char *kwnames[] = {
7852 (char *) "self", NULL
7853 };
7854
7855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
7856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7857 if (SWIG_arg_fail(1)) SWIG_fail;
7858 {
7859 PyThreadState* __tstate = wxPyBeginAllowThreads();
7860 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
7861
7862 wxPyEndAllowThreads(__tstate);
7863 if (PyErr_Occurred()) SWIG_fail;
7864 }
7865 resultobj = SWIG_From_int((result));
7866 return resultobj;
7867 fail:
7868 return NULL;
7869 }
7870
7871
7872 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
7873 PyObject *resultobj;
7874 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7875 wxFontEncoding result;
7876 PyObject * obj0 = 0 ;
7877 char *kwnames[] = {
7878 (char *) "self", NULL
7879 };
7880
7881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
7882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7883 if (SWIG_arg_fail(1)) SWIG_fail;
7884 {
7885 PyThreadState* __tstate = wxPyBeginAllowThreads();
7886 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
7887
7888 wxPyEndAllowThreads(__tstate);
7889 if (PyErr_Occurred()) SWIG_fail;
7890 }
7891 resultobj = SWIG_From_int((result));
7892 return resultobj;
7893 fail:
7894 return NULL;
7895 }
7896
7897
7898 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7899 PyObject *resultobj;
7900 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7901 int arg2 ;
7902 PyObject * obj0 = 0 ;
7903 PyObject * obj1 = 0 ;
7904 char *kwnames[] = {
7905 (char *) "self",(char *) "pointsize", NULL
7906 };
7907
7908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
7909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7910 if (SWIG_arg_fail(1)) SWIG_fail;
7911 {
7912 arg2 = (int)(SWIG_As_int(obj1));
7913 if (SWIG_arg_fail(2)) SWIG_fail;
7914 }
7915 {
7916 PyThreadState* __tstate = wxPyBeginAllowThreads();
7917 (arg1)->SetPointSize(arg2);
7918
7919 wxPyEndAllowThreads(__tstate);
7920 if (PyErr_Occurred()) SWIG_fail;
7921 }
7922 Py_INCREF(Py_None); resultobj = Py_None;
7923 return resultobj;
7924 fail:
7925 return NULL;
7926 }
7927
7928
7929 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7930 PyObject *resultobj;
7931 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7932 wxFontStyle arg2 ;
7933 PyObject * obj0 = 0 ;
7934 PyObject * obj1 = 0 ;
7935 char *kwnames[] = {
7936 (char *) "self",(char *) "style", NULL
7937 };
7938
7939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
7940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7941 if (SWIG_arg_fail(1)) SWIG_fail;
7942 {
7943 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
7944 if (SWIG_arg_fail(2)) SWIG_fail;
7945 }
7946 {
7947 PyThreadState* __tstate = wxPyBeginAllowThreads();
7948 (arg1)->SetStyle((wxFontStyle )arg2);
7949
7950 wxPyEndAllowThreads(__tstate);
7951 if (PyErr_Occurred()) SWIG_fail;
7952 }
7953 Py_INCREF(Py_None); resultobj = Py_None;
7954 return resultobj;
7955 fail:
7956 return NULL;
7957 }
7958
7959
7960 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7961 PyObject *resultobj;
7962 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7963 wxFontWeight arg2 ;
7964 PyObject * obj0 = 0 ;
7965 PyObject * obj1 = 0 ;
7966 char *kwnames[] = {
7967 (char *) "self",(char *) "weight", NULL
7968 };
7969
7970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
7971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7972 if (SWIG_arg_fail(1)) SWIG_fail;
7973 {
7974 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
7975 if (SWIG_arg_fail(2)) SWIG_fail;
7976 }
7977 {
7978 PyThreadState* __tstate = wxPyBeginAllowThreads();
7979 (arg1)->SetWeight((wxFontWeight )arg2);
7980
7981 wxPyEndAllowThreads(__tstate);
7982 if (PyErr_Occurred()) SWIG_fail;
7983 }
7984 Py_INCREF(Py_None); resultobj = Py_None;
7985 return resultobj;
7986 fail:
7987 return NULL;
7988 }
7989
7990
7991 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7992 PyObject *resultobj;
7993 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7994 bool arg2 ;
7995 PyObject * obj0 = 0 ;
7996 PyObject * obj1 = 0 ;
7997 char *kwnames[] = {
7998 (char *) "self",(char *) "underlined", NULL
7999 };
8000
8001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
8002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8003 if (SWIG_arg_fail(1)) SWIG_fail;
8004 {
8005 arg2 = (bool)(SWIG_As_bool(obj1));
8006 if (SWIG_arg_fail(2)) SWIG_fail;
8007 }
8008 {
8009 PyThreadState* __tstate = wxPyBeginAllowThreads();
8010 (arg1)->SetUnderlined(arg2);
8011
8012 wxPyEndAllowThreads(__tstate);
8013 if (PyErr_Occurred()) SWIG_fail;
8014 }
8015 Py_INCREF(Py_None); resultobj = Py_None;
8016 return resultobj;
8017 fail:
8018 return NULL;
8019 }
8020
8021
8022 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8023 PyObject *resultobj;
8024 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8025 wxString arg2 ;
8026 PyObject * obj0 = 0 ;
8027 PyObject * obj1 = 0 ;
8028 char *kwnames[] = {
8029 (char *) "self",(char *) "facename", NULL
8030 };
8031
8032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
8033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8034 if (SWIG_arg_fail(1)) SWIG_fail;
8035 {
8036 wxString* sptr = wxString_in_helper(obj1);
8037 if (sptr == NULL) SWIG_fail;
8038 arg2 = *sptr;
8039 delete sptr;
8040 }
8041 {
8042 PyThreadState* __tstate = wxPyBeginAllowThreads();
8043 (arg1)->SetFaceName(arg2);
8044
8045 wxPyEndAllowThreads(__tstate);
8046 if (PyErr_Occurred()) SWIG_fail;
8047 }
8048 Py_INCREF(Py_None); resultobj = Py_None;
8049 return resultobj;
8050 fail:
8051 return NULL;
8052 }
8053
8054
8055 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8056 PyObject *resultobj;
8057 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8058 wxFontFamily arg2 ;
8059 PyObject * obj0 = 0 ;
8060 PyObject * obj1 = 0 ;
8061 char *kwnames[] = {
8062 (char *) "self",(char *) "family", NULL
8063 };
8064
8065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8067 if (SWIG_arg_fail(1)) SWIG_fail;
8068 {
8069 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8070 if (SWIG_arg_fail(2)) SWIG_fail;
8071 }
8072 {
8073 PyThreadState* __tstate = wxPyBeginAllowThreads();
8074 (arg1)->SetFamily((wxFontFamily )arg2);
8075
8076 wxPyEndAllowThreads(__tstate);
8077 if (PyErr_Occurred()) SWIG_fail;
8078 }
8079 Py_INCREF(Py_None); resultobj = Py_None;
8080 return resultobj;
8081 fail:
8082 return NULL;
8083 }
8084
8085
8086 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8087 PyObject *resultobj;
8088 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8089 wxFontEncoding arg2 ;
8090 PyObject * obj0 = 0 ;
8091 PyObject * obj1 = 0 ;
8092 char *kwnames[] = {
8093 (char *) "self",(char *) "encoding", NULL
8094 };
8095
8096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8098 if (SWIG_arg_fail(1)) SWIG_fail;
8099 {
8100 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8101 if (SWIG_arg_fail(2)) SWIG_fail;
8102 }
8103 {
8104 PyThreadState* __tstate = wxPyBeginAllowThreads();
8105 (arg1)->SetEncoding((wxFontEncoding )arg2);
8106
8107 wxPyEndAllowThreads(__tstate);
8108 if (PyErr_Occurred()) SWIG_fail;
8109 }
8110 Py_INCREF(Py_None); resultobj = Py_None;
8111 return resultobj;
8112 fail:
8113 return NULL;
8114 }
8115
8116
8117 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8118 PyObject *resultobj;
8119 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8120 wxString *arg2 = 0 ;
8121 bool result;
8122 bool temp2 = false ;
8123 PyObject * obj0 = 0 ;
8124 PyObject * obj1 = 0 ;
8125 char *kwnames[] = {
8126 (char *) "self",(char *) "s", NULL
8127 };
8128
8129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8131 if (SWIG_arg_fail(1)) SWIG_fail;
8132 {
8133 arg2 = wxString_in_helper(obj1);
8134 if (arg2 == NULL) SWIG_fail;
8135 temp2 = true;
8136 }
8137 {
8138 PyThreadState* __tstate = wxPyBeginAllowThreads();
8139 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8140
8141 wxPyEndAllowThreads(__tstate);
8142 if (PyErr_Occurred()) SWIG_fail;
8143 }
8144 {
8145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8146 }
8147 {
8148 if (temp2)
8149 delete arg2;
8150 }
8151 return resultobj;
8152 fail:
8153 {
8154 if (temp2)
8155 delete arg2;
8156 }
8157 return NULL;
8158 }
8159
8160
8161 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8162 PyObject *resultobj;
8163 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8164 wxString result;
8165 PyObject * obj0 = 0 ;
8166 char *kwnames[] = {
8167 (char *) "self", NULL
8168 };
8169
8170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8172 if (SWIG_arg_fail(1)) SWIG_fail;
8173 {
8174 PyThreadState* __tstate = wxPyBeginAllowThreads();
8175 result = ((wxNativeFontInfo const *)arg1)->ToString();
8176
8177 wxPyEndAllowThreads(__tstate);
8178 if (PyErr_Occurred()) SWIG_fail;
8179 }
8180 {
8181 #if wxUSE_UNICODE
8182 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8183 #else
8184 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8185 #endif
8186 }
8187 return resultobj;
8188 fail:
8189 return NULL;
8190 }
8191
8192
8193 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8194 PyObject *resultobj;
8195 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8196 wxString result;
8197 PyObject * obj0 = 0 ;
8198 char *kwnames[] = {
8199 (char *) "self", NULL
8200 };
8201
8202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8204 if (SWIG_arg_fail(1)) SWIG_fail;
8205 {
8206 PyThreadState* __tstate = wxPyBeginAllowThreads();
8207 result = wxNativeFontInfo___str__(arg1);
8208
8209 wxPyEndAllowThreads(__tstate);
8210 if (PyErr_Occurred()) SWIG_fail;
8211 }
8212 {
8213 #if wxUSE_UNICODE
8214 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8215 #else
8216 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8217 #endif
8218 }
8219 return resultobj;
8220 fail:
8221 return NULL;
8222 }
8223
8224
8225 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8226 PyObject *resultobj;
8227 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8228 wxString *arg2 = 0 ;
8229 bool result;
8230 bool temp2 = false ;
8231 PyObject * obj0 = 0 ;
8232 PyObject * obj1 = 0 ;
8233 char *kwnames[] = {
8234 (char *) "self",(char *) "s", NULL
8235 };
8236
8237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",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 arg2 = wxString_in_helper(obj1);
8242 if (arg2 == NULL) SWIG_fail;
8243 temp2 = true;
8244 }
8245 {
8246 PyThreadState* __tstate = wxPyBeginAllowThreads();
8247 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8248
8249 wxPyEndAllowThreads(__tstate);
8250 if (PyErr_Occurred()) SWIG_fail;
8251 }
8252 {
8253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8254 }
8255 {
8256 if (temp2)
8257 delete arg2;
8258 }
8259 return resultobj;
8260 fail:
8261 {
8262 if (temp2)
8263 delete arg2;
8264 }
8265 return NULL;
8266 }
8267
8268
8269 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8270 PyObject *resultobj;
8271 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8272 wxString result;
8273 PyObject * obj0 = 0 ;
8274 char *kwnames[] = {
8275 (char *) "self", NULL
8276 };
8277
8278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8280 if (SWIG_arg_fail(1)) SWIG_fail;
8281 {
8282 PyThreadState* __tstate = wxPyBeginAllowThreads();
8283 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8284
8285 wxPyEndAllowThreads(__tstate);
8286 if (PyErr_Occurred()) SWIG_fail;
8287 }
8288 {
8289 #if wxUSE_UNICODE
8290 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8291 #else
8292 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8293 #endif
8294 }
8295 return resultobj;
8296 fail:
8297 return NULL;
8298 }
8299
8300
8301 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8302 PyObject *obj;
8303 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8304 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8305 Py_INCREF(obj);
8306 return Py_BuildValue((char *)"");
8307 }
8308 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8309 PyObject *resultobj;
8310 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8311 wxString *arg2 = (wxString *) 0 ;
8312 bool temp2 = false ;
8313 PyObject * obj0 = 0 ;
8314 PyObject * obj1 = 0 ;
8315 char *kwnames[] = {
8316 (char *) "self",(char *) "facename", NULL
8317 };
8318
8319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8321 if (SWIG_arg_fail(1)) SWIG_fail;
8322 {
8323 arg2 = wxString_in_helper(obj1);
8324 if (arg2 == NULL) SWIG_fail;
8325 temp2 = true;
8326 }
8327 if (arg1) (arg1)->facename = *arg2;
8328
8329 Py_INCREF(Py_None); resultobj = Py_None;
8330 {
8331 if (temp2)
8332 delete arg2;
8333 }
8334 return resultobj;
8335 fail:
8336 {
8337 if (temp2)
8338 delete arg2;
8339 }
8340 return NULL;
8341 }
8342
8343
8344 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8345 PyObject *resultobj;
8346 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8347 wxString *result;
8348 PyObject * obj0 = 0 ;
8349 char *kwnames[] = {
8350 (char *) "self", NULL
8351 };
8352
8353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
8354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8355 if (SWIG_arg_fail(1)) SWIG_fail;
8356 result = (wxString *)& ((arg1)->facename);
8357
8358 {
8359 #if wxUSE_UNICODE
8360 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8361 #else
8362 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8363 #endif
8364 }
8365 return resultobj;
8366 fail:
8367 return NULL;
8368 }
8369
8370
8371 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8372 PyObject *resultobj;
8373 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8374 wxFontEncoding arg2 ;
8375 PyObject * obj0 = 0 ;
8376 PyObject * obj1 = 0 ;
8377 char *kwnames[] = {
8378 (char *) "self",(char *) "encoding", NULL
8379 };
8380
8381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
8382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8383 if (SWIG_arg_fail(1)) SWIG_fail;
8384 {
8385 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8386 if (SWIG_arg_fail(2)) SWIG_fail;
8387 }
8388 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
8389
8390 Py_INCREF(Py_None); resultobj = Py_None;
8391 return resultobj;
8392 fail:
8393 return NULL;
8394 }
8395
8396
8397 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
8398 PyObject *resultobj;
8399 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8400 wxFontEncoding result;
8401 PyObject * obj0 = 0 ;
8402 char *kwnames[] = {
8403 (char *) "self", NULL
8404 };
8405
8406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
8407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8408 if (SWIG_arg_fail(1)) SWIG_fail;
8409 result = (wxFontEncoding) ((arg1)->encoding);
8410
8411 resultobj = SWIG_From_int((result));
8412 return resultobj;
8413 fail:
8414 return NULL;
8415 }
8416
8417
8418 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8419 PyObject *resultobj;
8420 wxNativeEncodingInfo *result;
8421 char *kwnames[] = {
8422 NULL
8423 };
8424
8425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
8426 {
8427 PyThreadState* __tstate = wxPyBeginAllowThreads();
8428 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
8429
8430 wxPyEndAllowThreads(__tstate);
8431 if (PyErr_Occurred()) SWIG_fail;
8432 }
8433 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
8434 return resultobj;
8435 fail:
8436 return NULL;
8437 }
8438
8439
8440 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8441 PyObject *resultobj;
8442 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8443 PyObject * obj0 = 0 ;
8444 char *kwnames[] = {
8445 (char *) "self", NULL
8446 };
8447
8448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
8449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8450 if (SWIG_arg_fail(1)) SWIG_fail;
8451 {
8452 PyThreadState* __tstate = wxPyBeginAllowThreads();
8453 delete arg1;
8454
8455 wxPyEndAllowThreads(__tstate);
8456 if (PyErr_Occurred()) SWIG_fail;
8457 }
8458 Py_INCREF(Py_None); resultobj = Py_None;
8459 return resultobj;
8460 fail:
8461 return NULL;
8462 }
8463
8464
8465 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8466 PyObject *resultobj;
8467 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8468 wxString *arg2 = 0 ;
8469 bool result;
8470 bool temp2 = false ;
8471 PyObject * obj0 = 0 ;
8472 PyObject * obj1 = 0 ;
8473 char *kwnames[] = {
8474 (char *) "self",(char *) "s", NULL
8475 };
8476
8477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8479 if (SWIG_arg_fail(1)) SWIG_fail;
8480 {
8481 arg2 = wxString_in_helper(obj1);
8482 if (arg2 == NULL) SWIG_fail;
8483 temp2 = true;
8484 }
8485 {
8486 PyThreadState* __tstate = wxPyBeginAllowThreads();
8487 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8488
8489 wxPyEndAllowThreads(__tstate);
8490 if (PyErr_Occurred()) SWIG_fail;
8491 }
8492 {
8493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8494 }
8495 {
8496 if (temp2)
8497 delete arg2;
8498 }
8499 return resultobj;
8500 fail:
8501 {
8502 if (temp2)
8503 delete arg2;
8504 }
8505 return NULL;
8506 }
8507
8508
8509 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8510 PyObject *resultobj;
8511 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8512 wxString result;
8513 PyObject * obj0 = 0 ;
8514 char *kwnames[] = {
8515 (char *) "self", NULL
8516 };
8517
8518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
8519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8520 if (SWIG_arg_fail(1)) SWIG_fail;
8521 {
8522 PyThreadState* __tstate = wxPyBeginAllowThreads();
8523 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
8524
8525 wxPyEndAllowThreads(__tstate);
8526 if (PyErr_Occurred()) SWIG_fail;
8527 }
8528 {
8529 #if wxUSE_UNICODE
8530 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8531 #else
8532 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8533 #endif
8534 }
8535 return resultobj;
8536 fail:
8537 return NULL;
8538 }
8539
8540
8541 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
8542 PyObject *obj;
8543 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8544 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
8545 Py_INCREF(obj);
8546 return Py_BuildValue((char *)"");
8547 }
8548 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8549 PyObject *resultobj;
8550 wxFontEncoding arg1 ;
8551 wxNativeEncodingInfo *result;
8552 PyObject * obj0 = 0 ;
8553 char *kwnames[] = {
8554 (char *) "encoding", NULL
8555 };
8556
8557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
8558 {
8559 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8560 if (SWIG_arg_fail(1)) SWIG_fail;
8561 }
8562 {
8563 PyThreadState* __tstate = wxPyBeginAllowThreads();
8564 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
8565
8566 wxPyEndAllowThreads(__tstate);
8567 if (PyErr_Occurred()) SWIG_fail;
8568 }
8569 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
8570 return resultobj;
8571 fail:
8572 return NULL;
8573 }
8574
8575
8576 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8577 PyObject *resultobj;
8578 wxNativeEncodingInfo *arg1 = 0 ;
8579 bool result;
8580 PyObject * obj0 = 0 ;
8581 char *kwnames[] = {
8582 (char *) "info", NULL
8583 };
8584
8585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
8586 {
8587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8588 if (SWIG_arg_fail(1)) SWIG_fail;
8589 if (arg1 == NULL) {
8590 SWIG_null_ref("wxNativeEncodingInfo");
8591 }
8592 if (SWIG_arg_fail(1)) SWIG_fail;
8593 }
8594 {
8595 PyThreadState* __tstate = wxPyBeginAllowThreads();
8596 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
8597
8598 wxPyEndAllowThreads(__tstate);
8599 if (PyErr_Occurred()) SWIG_fail;
8600 }
8601 {
8602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8603 }
8604 return resultobj;
8605 fail:
8606 return NULL;
8607 }
8608
8609
8610 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8611 PyObject *resultobj;
8612 wxFontMapper *result;
8613 char *kwnames[] = {
8614 NULL
8615 };
8616
8617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
8618 {
8619 PyThreadState* __tstate = wxPyBeginAllowThreads();
8620 result = (wxFontMapper *)new wxFontMapper();
8621
8622 wxPyEndAllowThreads(__tstate);
8623 if (PyErr_Occurred()) SWIG_fail;
8624 }
8625 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
8626 return resultobj;
8627 fail:
8628 return NULL;
8629 }
8630
8631
8632 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8633 PyObject *resultobj;
8634 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8635 PyObject * obj0 = 0 ;
8636 char *kwnames[] = {
8637 (char *) "self", NULL
8638 };
8639
8640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
8641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8642 if (SWIG_arg_fail(1)) SWIG_fail;
8643 {
8644 PyThreadState* __tstate = wxPyBeginAllowThreads();
8645 delete arg1;
8646
8647 wxPyEndAllowThreads(__tstate);
8648 if (PyErr_Occurred()) SWIG_fail;
8649 }
8650 Py_INCREF(Py_None); resultobj = Py_None;
8651 return resultobj;
8652 fail:
8653 return NULL;
8654 }
8655
8656
8657 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
8658 PyObject *resultobj;
8659 wxFontMapper *result;
8660 char *kwnames[] = {
8661 NULL
8662 };
8663
8664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
8665 {
8666 PyThreadState* __tstate = wxPyBeginAllowThreads();
8667 result = (wxFontMapper *)wxFontMapper::Get();
8668
8669 wxPyEndAllowThreads(__tstate);
8670 if (PyErr_Occurred()) SWIG_fail;
8671 }
8672 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8673 return resultobj;
8674 fail:
8675 return NULL;
8676 }
8677
8678
8679 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
8680 PyObject *resultobj;
8681 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8682 wxFontMapper *result;
8683 PyObject * obj0 = 0 ;
8684 char *kwnames[] = {
8685 (char *) "mapper", NULL
8686 };
8687
8688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
8689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8690 if (SWIG_arg_fail(1)) SWIG_fail;
8691 {
8692 PyThreadState* __tstate = wxPyBeginAllowThreads();
8693 result = (wxFontMapper *)wxFontMapper::Set(arg1);
8694
8695 wxPyEndAllowThreads(__tstate);
8696 if (PyErr_Occurred()) SWIG_fail;
8697 }
8698 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8699 return resultobj;
8700 fail:
8701 return NULL;
8702 }
8703
8704
8705 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8706 PyObject *resultobj;
8707 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8708 wxString *arg2 = 0 ;
8709 bool arg3 = (bool) true ;
8710 wxFontEncoding result;
8711 bool temp2 = false ;
8712 PyObject * obj0 = 0 ;
8713 PyObject * obj1 = 0 ;
8714 PyObject * obj2 = 0 ;
8715 char *kwnames[] = {
8716 (char *) "self",(char *) "charset",(char *) "interactive", NULL
8717 };
8718
8719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
8720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8721 if (SWIG_arg_fail(1)) SWIG_fail;
8722 {
8723 arg2 = wxString_in_helper(obj1);
8724 if (arg2 == NULL) SWIG_fail;
8725 temp2 = true;
8726 }
8727 if (obj2) {
8728 {
8729 arg3 = (bool)(SWIG_As_bool(obj2));
8730 if (SWIG_arg_fail(3)) SWIG_fail;
8731 }
8732 }
8733 {
8734 PyThreadState* __tstate = wxPyBeginAllowThreads();
8735 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
8736
8737 wxPyEndAllowThreads(__tstate);
8738 if (PyErr_Occurred()) SWIG_fail;
8739 }
8740 resultobj = SWIG_From_int((result));
8741 {
8742 if (temp2)
8743 delete arg2;
8744 }
8745 return resultobj;
8746 fail:
8747 {
8748 if (temp2)
8749 delete arg2;
8750 }
8751 return NULL;
8752 }
8753
8754
8755 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
8756 PyObject *resultobj;
8757 size_t result;
8758 char *kwnames[] = {
8759 NULL
8760 };
8761
8762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
8763 {
8764 PyThreadState* __tstate = wxPyBeginAllowThreads();
8765 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
8766
8767 wxPyEndAllowThreads(__tstate);
8768 if (PyErr_Occurred()) SWIG_fail;
8769 }
8770 {
8771 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8772 }
8773 return resultobj;
8774 fail:
8775 return NULL;
8776 }
8777
8778
8779 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8780 PyObject *resultobj;
8781 size_t arg1 ;
8782 wxFontEncoding result;
8783 PyObject * obj0 = 0 ;
8784 char *kwnames[] = {
8785 (char *) "n", NULL
8786 };
8787
8788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
8789 {
8790 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8791 if (SWIG_arg_fail(1)) SWIG_fail;
8792 }
8793 {
8794 PyThreadState* __tstate = wxPyBeginAllowThreads();
8795 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
8796
8797 wxPyEndAllowThreads(__tstate);
8798 if (PyErr_Occurred()) SWIG_fail;
8799 }
8800 resultobj = SWIG_From_int((result));
8801 return resultobj;
8802 fail:
8803 return NULL;
8804 }
8805
8806
8807 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
8808 PyObject *resultobj;
8809 wxFontEncoding arg1 ;
8810 wxString result;
8811 PyObject * obj0 = 0 ;
8812 char *kwnames[] = {
8813 (char *) "encoding", NULL
8814 };
8815
8816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
8817 {
8818 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8819 if (SWIG_arg_fail(1)) SWIG_fail;
8820 }
8821 {
8822 PyThreadState* __tstate = wxPyBeginAllowThreads();
8823 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
8824
8825 wxPyEndAllowThreads(__tstate);
8826 if (PyErr_Occurred()) SWIG_fail;
8827 }
8828 {
8829 #if wxUSE_UNICODE
8830 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8831 #else
8832 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8833 #endif
8834 }
8835 return resultobj;
8836 fail:
8837 return NULL;
8838 }
8839
8840
8841 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
8842 PyObject *resultobj;
8843 wxFontEncoding arg1 ;
8844 wxString result;
8845 PyObject * obj0 = 0 ;
8846 char *kwnames[] = {
8847 (char *) "encoding", NULL
8848 };
8849
8850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
8851 {
8852 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8853 if (SWIG_arg_fail(1)) SWIG_fail;
8854 }
8855 {
8856 PyThreadState* __tstate = wxPyBeginAllowThreads();
8857 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
8858
8859 wxPyEndAllowThreads(__tstate);
8860 if (PyErr_Occurred()) SWIG_fail;
8861 }
8862 {
8863 #if wxUSE_UNICODE
8864 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8865 #else
8866 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8867 #endif
8868 }
8869 return resultobj;
8870 fail:
8871 return NULL;
8872 }
8873
8874
8875 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
8876 PyObject *resultobj;
8877 wxString *arg1 = 0 ;
8878 wxFontEncoding result;
8879 bool temp1 = false ;
8880 PyObject * obj0 = 0 ;
8881 char *kwnames[] = {
8882 (char *) "name", NULL
8883 };
8884
8885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
8886 {
8887 arg1 = wxString_in_helper(obj0);
8888 if (arg1 == NULL) SWIG_fail;
8889 temp1 = true;
8890 }
8891 {
8892 PyThreadState* __tstate = wxPyBeginAllowThreads();
8893 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
8894
8895 wxPyEndAllowThreads(__tstate);
8896 if (PyErr_Occurred()) SWIG_fail;
8897 }
8898 resultobj = SWIG_From_int((result));
8899 {
8900 if (temp1)
8901 delete arg1;
8902 }
8903 return resultobj;
8904 fail:
8905 {
8906 if (temp1)
8907 delete arg1;
8908 }
8909 return NULL;
8910 }
8911
8912
8913 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
8914 PyObject *resultobj;
8915 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8916 wxConfigBase *arg2 = (wxConfigBase *) 0 ;
8917 PyObject * obj0 = 0 ;
8918 PyObject * obj1 = 0 ;
8919 char *kwnames[] = {
8920 (char *) "self",(char *) "config", NULL
8921 };
8922
8923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
8924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8925 if (SWIG_arg_fail(1)) SWIG_fail;
8926 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8927 if (SWIG_arg_fail(2)) SWIG_fail;
8928 {
8929 PyThreadState* __tstate = wxPyBeginAllowThreads();
8930 (arg1)->SetConfig(arg2);
8931
8932 wxPyEndAllowThreads(__tstate);
8933 if (PyErr_Occurred()) SWIG_fail;
8934 }
8935 Py_INCREF(Py_None); resultobj = Py_None;
8936 return resultobj;
8937 fail:
8938 return NULL;
8939 }
8940
8941
8942 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8943 PyObject *resultobj;
8944 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8945 wxString *arg2 = 0 ;
8946 bool temp2 = false ;
8947 PyObject * obj0 = 0 ;
8948 PyObject * obj1 = 0 ;
8949 char *kwnames[] = {
8950 (char *) "self",(char *) "prefix", NULL
8951 };
8952
8953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
8954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8955 if (SWIG_arg_fail(1)) SWIG_fail;
8956 {
8957 arg2 = wxString_in_helper(obj1);
8958 if (arg2 == NULL) SWIG_fail;
8959 temp2 = true;
8960 }
8961 {
8962 PyThreadState* __tstate = wxPyBeginAllowThreads();
8963 (arg1)->SetConfigPath((wxString const &)*arg2);
8964
8965 wxPyEndAllowThreads(__tstate);
8966 if (PyErr_Occurred()) SWIG_fail;
8967 }
8968 Py_INCREF(Py_None); resultobj = Py_None;
8969 {
8970 if (temp2)
8971 delete arg2;
8972 }
8973 return resultobj;
8974 fail:
8975 {
8976 if (temp2)
8977 delete arg2;
8978 }
8979 return NULL;
8980 }
8981
8982
8983 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8984 PyObject *resultobj;
8985 wxString result;
8986 char *kwnames[] = {
8987 NULL
8988 };
8989
8990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
8991 {
8992 PyThreadState* __tstate = wxPyBeginAllowThreads();
8993 result = wxFontMapper::GetDefaultConfigPath();
8994
8995 wxPyEndAllowThreads(__tstate);
8996 if (PyErr_Occurred()) SWIG_fail;
8997 }
8998 {
8999 #if wxUSE_UNICODE
9000 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9001 #else
9002 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9003 #endif
9004 }
9005 return resultobj;
9006 fail:
9007 return NULL;
9008 }
9009
9010
9011 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9012 PyObject *resultobj;
9013 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9014 wxFontEncoding arg2 ;
9015 wxString const &arg3_defvalue = wxPyEmptyString ;
9016 wxString *arg3 = (wxString *) &arg3_defvalue ;
9017 bool arg4 = (bool) true ;
9018 PyObject *result;
9019 bool temp3 = false ;
9020 PyObject * obj0 = 0 ;
9021 PyObject * obj1 = 0 ;
9022 PyObject * obj2 = 0 ;
9023 PyObject * obj3 = 0 ;
9024 char *kwnames[] = {
9025 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
9026 };
9027
9028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9030 if (SWIG_arg_fail(1)) SWIG_fail;
9031 {
9032 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9033 if (SWIG_arg_fail(2)) SWIG_fail;
9034 }
9035 if (obj2) {
9036 {
9037 arg3 = wxString_in_helper(obj2);
9038 if (arg3 == NULL) SWIG_fail;
9039 temp3 = true;
9040 }
9041 }
9042 if (obj3) {
9043 {
9044 arg4 = (bool)(SWIG_As_bool(obj3));
9045 if (SWIG_arg_fail(4)) SWIG_fail;
9046 }
9047 }
9048 {
9049 PyThreadState* __tstate = wxPyBeginAllowThreads();
9050 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9051
9052 wxPyEndAllowThreads(__tstate);
9053 if (PyErr_Occurred()) SWIG_fail;
9054 }
9055 resultobj = result;
9056 {
9057 if (temp3)
9058 delete arg3;
9059 }
9060 return resultobj;
9061 fail:
9062 {
9063 if (temp3)
9064 delete arg3;
9065 }
9066 return NULL;
9067 }
9068
9069
9070 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9071 PyObject *resultobj;
9072 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9073 wxFontEncoding arg2 ;
9074 wxString const &arg3_defvalue = wxPyEmptyString ;
9075 wxString *arg3 = (wxString *) &arg3_defvalue ;
9076 bool result;
9077 bool temp3 = false ;
9078 PyObject * obj0 = 0 ;
9079 PyObject * obj1 = 0 ;
9080 PyObject * obj2 = 0 ;
9081 char *kwnames[] = {
9082 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9083 };
9084
9085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9087 if (SWIG_arg_fail(1)) SWIG_fail;
9088 {
9089 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9090 if (SWIG_arg_fail(2)) SWIG_fail;
9091 }
9092 if (obj2) {
9093 {
9094 arg3 = wxString_in_helper(obj2);
9095 if (arg3 == NULL) SWIG_fail;
9096 temp3 = true;
9097 }
9098 }
9099 {
9100 PyThreadState* __tstate = wxPyBeginAllowThreads();
9101 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9102
9103 wxPyEndAllowThreads(__tstate);
9104 if (PyErr_Occurred()) SWIG_fail;
9105 }
9106 {
9107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9108 }
9109 {
9110 if (temp3)
9111 delete arg3;
9112 }
9113 return resultobj;
9114 fail:
9115 {
9116 if (temp3)
9117 delete arg3;
9118 }
9119 return NULL;
9120 }
9121
9122
9123 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9124 PyObject *resultobj;
9125 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9126 wxWindow *arg2 = (wxWindow *) 0 ;
9127 PyObject * obj0 = 0 ;
9128 PyObject * obj1 = 0 ;
9129 char *kwnames[] = {
9130 (char *) "self",(char *) "parent", NULL
9131 };
9132
9133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9135 if (SWIG_arg_fail(1)) SWIG_fail;
9136 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9137 if (SWIG_arg_fail(2)) SWIG_fail;
9138 {
9139 PyThreadState* __tstate = wxPyBeginAllowThreads();
9140 (arg1)->SetDialogParent(arg2);
9141
9142 wxPyEndAllowThreads(__tstate);
9143 if (PyErr_Occurred()) SWIG_fail;
9144 }
9145 Py_INCREF(Py_None); resultobj = Py_None;
9146 return resultobj;
9147 fail:
9148 return NULL;
9149 }
9150
9151
9152 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9153 PyObject *resultobj;
9154 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9155 wxString *arg2 = 0 ;
9156 bool temp2 = false ;
9157 PyObject * obj0 = 0 ;
9158 PyObject * obj1 = 0 ;
9159 char *kwnames[] = {
9160 (char *) "self",(char *) "title", NULL
9161 };
9162
9163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9165 if (SWIG_arg_fail(1)) SWIG_fail;
9166 {
9167 arg2 = wxString_in_helper(obj1);
9168 if (arg2 == NULL) SWIG_fail;
9169 temp2 = true;
9170 }
9171 {
9172 PyThreadState* __tstate = wxPyBeginAllowThreads();
9173 (arg1)->SetDialogTitle((wxString const &)*arg2);
9174
9175 wxPyEndAllowThreads(__tstate);
9176 if (PyErr_Occurred()) SWIG_fail;
9177 }
9178 Py_INCREF(Py_None); resultobj = Py_None;
9179 {
9180 if (temp2)
9181 delete arg2;
9182 }
9183 return resultobj;
9184 fail:
9185 {
9186 if (temp2)
9187 delete arg2;
9188 }
9189 return NULL;
9190 }
9191
9192
9193 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9194 PyObject *obj;
9195 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9196 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9197 Py_INCREF(obj);
9198 return Py_BuildValue((char *)"");
9199 }
9200 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9201 PyObject *resultobj;
9202 int arg1 ;
9203 int arg2 ;
9204 int arg3 ;
9205 int arg4 ;
9206 bool arg5 = (bool) false ;
9207 wxString const &arg6_defvalue = wxPyEmptyString ;
9208 wxString *arg6 = (wxString *) &arg6_defvalue ;
9209 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9210 wxFont *result;
9211 bool temp6 = false ;
9212 PyObject * obj0 = 0 ;
9213 PyObject * obj1 = 0 ;
9214 PyObject * obj2 = 0 ;
9215 PyObject * obj3 = 0 ;
9216 PyObject * obj4 = 0 ;
9217 PyObject * obj5 = 0 ;
9218 PyObject * obj6 = 0 ;
9219 char *kwnames[] = {
9220 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9221 };
9222
9223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9224 {
9225 arg1 = (int)(SWIG_As_int(obj0));
9226 if (SWIG_arg_fail(1)) SWIG_fail;
9227 }
9228 {
9229 arg2 = (int)(SWIG_As_int(obj1));
9230 if (SWIG_arg_fail(2)) SWIG_fail;
9231 }
9232 {
9233 arg3 = (int)(SWIG_As_int(obj2));
9234 if (SWIG_arg_fail(3)) SWIG_fail;
9235 }
9236 {
9237 arg4 = (int)(SWIG_As_int(obj3));
9238 if (SWIG_arg_fail(4)) SWIG_fail;
9239 }
9240 if (obj4) {
9241 {
9242 arg5 = (bool)(SWIG_As_bool(obj4));
9243 if (SWIG_arg_fail(5)) SWIG_fail;
9244 }
9245 }
9246 if (obj5) {
9247 {
9248 arg6 = wxString_in_helper(obj5);
9249 if (arg6 == NULL) SWIG_fail;
9250 temp6 = true;
9251 }
9252 }
9253 if (obj6) {
9254 {
9255 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9256 if (SWIG_arg_fail(7)) SWIG_fail;
9257 }
9258 }
9259 {
9260 if (!wxPyCheckForApp()) SWIG_fail;
9261 PyThreadState* __tstate = wxPyBeginAllowThreads();
9262 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9263
9264 wxPyEndAllowThreads(__tstate);
9265 if (PyErr_Occurred()) SWIG_fail;
9266 }
9267 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9268 {
9269 if (temp6)
9270 delete arg6;
9271 }
9272 return resultobj;
9273 fail:
9274 {
9275 if (temp6)
9276 delete arg6;
9277 }
9278 return NULL;
9279 }
9280
9281
9282 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9283 PyObject *resultobj;
9284 wxFont *arg1 = (wxFont *) 0 ;
9285 PyObject * obj0 = 0 ;
9286 char *kwnames[] = {
9287 (char *) "self", NULL
9288 };
9289
9290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9292 if (SWIG_arg_fail(1)) SWIG_fail;
9293 {
9294 PyThreadState* __tstate = wxPyBeginAllowThreads();
9295 delete arg1;
9296
9297 wxPyEndAllowThreads(__tstate);
9298 if (PyErr_Occurred()) SWIG_fail;
9299 }
9300 Py_INCREF(Py_None); resultobj = Py_None;
9301 return resultobj;
9302 fail:
9303 return NULL;
9304 }
9305
9306
9307 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9308 PyObject *resultobj;
9309 wxNativeFontInfo *arg1 = 0 ;
9310 wxFont *result;
9311 PyObject * obj0 = 0 ;
9312 char *kwnames[] = {
9313 (char *) "info", NULL
9314 };
9315
9316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9317 {
9318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9319 if (SWIG_arg_fail(1)) SWIG_fail;
9320 if (arg1 == NULL) {
9321 SWIG_null_ref("wxNativeFontInfo");
9322 }
9323 if (SWIG_arg_fail(1)) SWIG_fail;
9324 }
9325 {
9326 if (!wxPyCheckForApp()) SWIG_fail;
9327 PyThreadState* __tstate = wxPyBeginAllowThreads();
9328 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9329
9330 wxPyEndAllowThreads(__tstate);
9331 if (PyErr_Occurred()) SWIG_fail;
9332 }
9333 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9334 return resultobj;
9335 fail:
9336 return NULL;
9337 }
9338
9339
9340 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9341 PyObject *resultobj;
9342 wxString *arg1 = 0 ;
9343 wxFont *result;
9344 bool temp1 = false ;
9345 PyObject * obj0 = 0 ;
9346 char *kwnames[] = {
9347 (char *) "info", NULL
9348 };
9349
9350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9351 {
9352 arg1 = wxString_in_helper(obj0);
9353 if (arg1 == NULL) SWIG_fail;
9354 temp1 = true;
9355 }
9356 {
9357 if (!wxPyCheckForApp()) SWIG_fail;
9358 PyThreadState* __tstate = wxPyBeginAllowThreads();
9359 result = (wxFont *)new_wxFont((wxString const &)*arg1);
9360
9361 wxPyEndAllowThreads(__tstate);
9362 if (PyErr_Occurred()) SWIG_fail;
9363 }
9364 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9365 {
9366 if (temp1)
9367 delete arg1;
9368 }
9369 return resultobj;
9370 fail:
9371 {
9372 if (temp1)
9373 delete arg1;
9374 }
9375 return NULL;
9376 }
9377
9378
9379 static PyObject *_wrap_new_FFont(PyObject *, PyObject *args, PyObject *kwargs) {
9380 PyObject *resultobj;
9381 int arg1 ;
9382 wxFontFamily arg2 ;
9383 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9384 wxString const &arg4_defvalue = wxPyEmptyString ;
9385 wxString *arg4 = (wxString *) &arg4_defvalue ;
9386 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9387 wxFont *result;
9388 bool temp4 = false ;
9389 PyObject * obj0 = 0 ;
9390 PyObject * obj1 = 0 ;
9391 PyObject * obj2 = 0 ;
9392 PyObject * obj3 = 0 ;
9393 PyObject * obj4 = 0 ;
9394 char *kwnames[] = {
9395 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9396 };
9397
9398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9399 {
9400 arg1 = (int)(SWIG_As_int(obj0));
9401 if (SWIG_arg_fail(1)) SWIG_fail;
9402 }
9403 {
9404 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9405 if (SWIG_arg_fail(2)) SWIG_fail;
9406 }
9407 if (obj2) {
9408 {
9409 arg3 = (int)(SWIG_As_int(obj2));
9410 if (SWIG_arg_fail(3)) SWIG_fail;
9411 }
9412 }
9413 if (obj3) {
9414 {
9415 arg4 = wxString_in_helper(obj3);
9416 if (arg4 == NULL) SWIG_fail;
9417 temp4 = true;
9418 }
9419 }
9420 if (obj4) {
9421 {
9422 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9423 if (SWIG_arg_fail(5)) SWIG_fail;
9424 }
9425 }
9426 {
9427 if (!wxPyCheckForApp()) SWIG_fail;
9428 PyThreadState* __tstate = wxPyBeginAllowThreads();
9429 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9430
9431 wxPyEndAllowThreads(__tstate);
9432 if (PyErr_Occurred()) SWIG_fail;
9433 }
9434 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9435 {
9436 if (temp4)
9437 delete arg4;
9438 }
9439 return resultobj;
9440 fail:
9441 {
9442 if (temp4)
9443 delete arg4;
9444 }
9445 return NULL;
9446 }
9447
9448
9449 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9450 PyObject *resultobj;
9451 wxSize *arg1 = 0 ;
9452 int arg2 ;
9453 int arg3 ;
9454 int arg4 ;
9455 bool arg5 = (bool) false ;
9456 wxString const &arg6_defvalue = wxEmptyString ;
9457 wxString *arg6 = (wxString *) &arg6_defvalue ;
9458 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9459 wxFont *result;
9460 wxSize temp1 ;
9461 bool temp6 = false ;
9462 PyObject * obj0 = 0 ;
9463 PyObject * obj1 = 0 ;
9464 PyObject * obj2 = 0 ;
9465 PyObject * obj3 = 0 ;
9466 PyObject * obj4 = 0 ;
9467 PyObject * obj5 = 0 ;
9468 PyObject * obj6 = 0 ;
9469 char *kwnames[] = {
9470 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
9471 };
9472
9473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9474 {
9475 arg1 = &temp1;
9476 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9477 }
9478 {
9479 arg2 = (int)(SWIG_As_int(obj1));
9480 if (SWIG_arg_fail(2)) SWIG_fail;
9481 }
9482 {
9483 arg3 = (int)(SWIG_As_int(obj2));
9484 if (SWIG_arg_fail(3)) SWIG_fail;
9485 }
9486 {
9487 arg4 = (int)(SWIG_As_int(obj3));
9488 if (SWIG_arg_fail(4)) SWIG_fail;
9489 }
9490 if (obj4) {
9491 {
9492 arg5 = (bool)(SWIG_As_bool(obj4));
9493 if (SWIG_arg_fail(5)) SWIG_fail;
9494 }
9495 }
9496 if (obj5) {
9497 {
9498 arg6 = wxString_in_helper(obj5);
9499 if (arg6 == NULL) SWIG_fail;
9500 temp6 = true;
9501 }
9502 }
9503 if (obj6) {
9504 {
9505 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9506 if (SWIG_arg_fail(7)) SWIG_fail;
9507 }
9508 }
9509 {
9510 if (!wxPyCheckForApp()) SWIG_fail;
9511 PyThreadState* __tstate = wxPyBeginAllowThreads();
9512 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9513
9514 wxPyEndAllowThreads(__tstate);
9515 if (PyErr_Occurred()) SWIG_fail;
9516 }
9517 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9518 {
9519 if (temp6)
9520 delete arg6;
9521 }
9522 return resultobj;
9523 fail:
9524 {
9525 if (temp6)
9526 delete arg6;
9527 }
9528 return NULL;
9529 }
9530
9531
9532 static PyObject *_wrap_new_FFontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9533 PyObject *resultobj;
9534 wxSize *arg1 = 0 ;
9535 wxFontFamily arg2 ;
9536 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9537 wxString const &arg4_defvalue = wxEmptyString ;
9538 wxString *arg4 = (wxString *) &arg4_defvalue ;
9539 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9540 wxFont *result;
9541 wxSize temp1 ;
9542 bool temp4 = false ;
9543 PyObject * obj0 = 0 ;
9544 PyObject * obj1 = 0 ;
9545 PyObject * obj2 = 0 ;
9546 PyObject * obj3 = 0 ;
9547 PyObject * obj4 = 0 ;
9548 char *kwnames[] = {
9549 (char *) "pixelSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9550 };
9551
9552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9553 {
9554 arg1 = &temp1;
9555 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9556 }
9557 {
9558 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9559 if (SWIG_arg_fail(2)) SWIG_fail;
9560 }
9561 if (obj2) {
9562 {
9563 arg3 = (int)(SWIG_As_int(obj2));
9564 if (SWIG_arg_fail(3)) SWIG_fail;
9565 }
9566 }
9567 if (obj3) {
9568 {
9569 arg4 = wxString_in_helper(obj3);
9570 if (arg4 == NULL) SWIG_fail;
9571 temp4 = true;
9572 }
9573 }
9574 if (obj4) {
9575 {
9576 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9577 if (SWIG_arg_fail(5)) SWIG_fail;
9578 }
9579 }
9580 {
9581 if (!wxPyCheckForApp()) SWIG_fail;
9582 PyThreadState* __tstate = wxPyBeginAllowThreads();
9583 result = (wxFont *)new_wxFont((wxSize const &)*arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9584
9585 wxPyEndAllowThreads(__tstate);
9586 if (PyErr_Occurred()) SWIG_fail;
9587 }
9588 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9589 {
9590 if (temp4)
9591 delete arg4;
9592 }
9593 return resultobj;
9594 fail:
9595 {
9596 if (temp4)
9597 delete arg4;
9598 }
9599 return NULL;
9600 }
9601
9602
9603 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
9604 PyObject *resultobj;
9605 wxFont *arg1 = (wxFont *) 0 ;
9606 bool result;
9607 PyObject * obj0 = 0 ;
9608 char *kwnames[] = {
9609 (char *) "self", NULL
9610 };
9611
9612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
9613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9614 if (SWIG_arg_fail(1)) SWIG_fail;
9615 {
9616 PyThreadState* __tstate = wxPyBeginAllowThreads();
9617 result = (bool)((wxFont const *)arg1)->Ok();
9618
9619 wxPyEndAllowThreads(__tstate);
9620 if (PyErr_Occurred()) SWIG_fail;
9621 }
9622 {
9623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9624 }
9625 return resultobj;
9626 fail:
9627 return NULL;
9628 }
9629
9630
9631 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9632 PyObject *resultobj;
9633 wxFont *arg1 = (wxFont *) 0 ;
9634 wxFont *arg2 = (wxFont *) 0 ;
9635 bool result;
9636 PyObject * obj0 = 0 ;
9637 PyObject * obj1 = 0 ;
9638 char *kwnames[] = {
9639 (char *) "self",(char *) "other", NULL
9640 };
9641
9642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
9643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9644 if (SWIG_arg_fail(1)) SWIG_fail;
9645 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9646 if (SWIG_arg_fail(2)) SWIG_fail;
9647 {
9648 PyThreadState* __tstate = wxPyBeginAllowThreads();
9649 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
9650
9651 wxPyEndAllowThreads(__tstate);
9652 if (PyErr_Occurred()) SWIG_fail;
9653 }
9654 {
9655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9656 }
9657 return resultobj;
9658 fail:
9659 return NULL;
9660 }
9661
9662
9663 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9664 PyObject *resultobj;
9665 wxFont *arg1 = (wxFont *) 0 ;
9666 wxFont *arg2 = (wxFont *) 0 ;
9667 bool result;
9668 PyObject * obj0 = 0 ;
9669 PyObject * obj1 = 0 ;
9670 char *kwnames[] = {
9671 (char *) "self",(char *) "other", NULL
9672 };
9673
9674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
9675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9676 if (SWIG_arg_fail(1)) SWIG_fail;
9677 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9678 if (SWIG_arg_fail(2)) SWIG_fail;
9679 {
9680 PyThreadState* __tstate = wxPyBeginAllowThreads();
9681 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
9682
9683 wxPyEndAllowThreads(__tstate);
9684 if (PyErr_Occurred()) SWIG_fail;
9685 }
9686 {
9687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9688 }
9689 return resultobj;
9690 fail:
9691 return NULL;
9692 }
9693
9694
9695 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9696 PyObject *resultobj;
9697 wxFont *arg1 = (wxFont *) 0 ;
9698 int result;
9699 PyObject * obj0 = 0 ;
9700 char *kwnames[] = {
9701 (char *) "self", NULL
9702 };
9703
9704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
9705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9706 if (SWIG_arg_fail(1)) SWIG_fail;
9707 {
9708 PyThreadState* __tstate = wxPyBeginAllowThreads();
9709 result = (int)((wxFont const *)arg1)->GetPointSize();
9710
9711 wxPyEndAllowThreads(__tstate);
9712 if (PyErr_Occurred()) SWIG_fail;
9713 }
9714 {
9715 resultobj = SWIG_From_int((int)(result));
9716 }
9717 return resultobj;
9718 fail:
9719 return NULL;
9720 }
9721
9722
9723 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9724 PyObject *resultobj;
9725 wxFont *arg1 = (wxFont *) 0 ;
9726 wxSize result;
9727 PyObject * obj0 = 0 ;
9728 char *kwnames[] = {
9729 (char *) "self", NULL
9730 };
9731
9732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
9733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9734 if (SWIG_arg_fail(1)) SWIG_fail;
9735 {
9736 PyThreadState* __tstate = wxPyBeginAllowThreads();
9737 result = ((wxFont const *)arg1)->GetPixelSize();
9738
9739 wxPyEndAllowThreads(__tstate);
9740 if (PyErr_Occurred()) SWIG_fail;
9741 }
9742 {
9743 wxSize * resultptr;
9744 resultptr = new wxSize((wxSize &)(result));
9745 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
9746 }
9747 return resultobj;
9748 fail:
9749 return NULL;
9750 }
9751
9752
9753 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
9754 PyObject *resultobj;
9755 wxFont *arg1 = (wxFont *) 0 ;
9756 bool result;
9757 PyObject * obj0 = 0 ;
9758 char *kwnames[] = {
9759 (char *) "self", NULL
9760 };
9761
9762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
9763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9764 if (SWIG_arg_fail(1)) SWIG_fail;
9765 {
9766 PyThreadState* __tstate = wxPyBeginAllowThreads();
9767 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
9768
9769 wxPyEndAllowThreads(__tstate);
9770 if (PyErr_Occurred()) SWIG_fail;
9771 }
9772 {
9773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9774 }
9775 return resultobj;
9776 fail:
9777 return NULL;
9778 }
9779
9780
9781 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
9782 PyObject *resultobj;
9783 wxFont *arg1 = (wxFont *) 0 ;
9784 int result;
9785 PyObject * obj0 = 0 ;
9786 char *kwnames[] = {
9787 (char *) "self", NULL
9788 };
9789
9790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
9791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9792 if (SWIG_arg_fail(1)) SWIG_fail;
9793 {
9794 PyThreadState* __tstate = wxPyBeginAllowThreads();
9795 result = (int)((wxFont const *)arg1)->GetFamily();
9796
9797 wxPyEndAllowThreads(__tstate);
9798 if (PyErr_Occurred()) SWIG_fail;
9799 }
9800 {
9801 resultobj = SWIG_From_int((int)(result));
9802 }
9803 return resultobj;
9804 fail:
9805 return NULL;
9806 }
9807
9808
9809 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
9810 PyObject *resultobj;
9811 wxFont *arg1 = (wxFont *) 0 ;
9812 int result;
9813 PyObject * obj0 = 0 ;
9814 char *kwnames[] = {
9815 (char *) "self", NULL
9816 };
9817
9818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
9819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9820 if (SWIG_arg_fail(1)) SWIG_fail;
9821 {
9822 PyThreadState* __tstate = wxPyBeginAllowThreads();
9823 result = (int)((wxFont const *)arg1)->GetStyle();
9824
9825 wxPyEndAllowThreads(__tstate);
9826 if (PyErr_Occurred()) SWIG_fail;
9827 }
9828 {
9829 resultobj = SWIG_From_int((int)(result));
9830 }
9831 return resultobj;
9832 fail:
9833 return NULL;
9834 }
9835
9836
9837 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
9838 PyObject *resultobj;
9839 wxFont *arg1 = (wxFont *) 0 ;
9840 int result;
9841 PyObject * obj0 = 0 ;
9842 char *kwnames[] = {
9843 (char *) "self", NULL
9844 };
9845
9846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
9847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9848 if (SWIG_arg_fail(1)) SWIG_fail;
9849 {
9850 PyThreadState* __tstate = wxPyBeginAllowThreads();
9851 result = (int)((wxFont const *)arg1)->GetWeight();
9852
9853 wxPyEndAllowThreads(__tstate);
9854 if (PyErr_Occurred()) SWIG_fail;
9855 }
9856 {
9857 resultobj = SWIG_From_int((int)(result));
9858 }
9859 return resultobj;
9860 fail:
9861 return NULL;
9862 }
9863
9864
9865 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
9866 PyObject *resultobj;
9867 wxFont *arg1 = (wxFont *) 0 ;
9868 bool result;
9869 PyObject * obj0 = 0 ;
9870 char *kwnames[] = {
9871 (char *) "self", NULL
9872 };
9873
9874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
9875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9876 if (SWIG_arg_fail(1)) SWIG_fail;
9877 {
9878 PyThreadState* __tstate = wxPyBeginAllowThreads();
9879 result = (bool)((wxFont const *)arg1)->GetUnderlined();
9880
9881 wxPyEndAllowThreads(__tstate);
9882 if (PyErr_Occurred()) SWIG_fail;
9883 }
9884 {
9885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9886 }
9887 return resultobj;
9888 fail:
9889 return NULL;
9890 }
9891
9892
9893 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
9894 PyObject *resultobj;
9895 wxFont *arg1 = (wxFont *) 0 ;
9896 wxString result;
9897 PyObject * obj0 = 0 ;
9898 char *kwnames[] = {
9899 (char *) "self", NULL
9900 };
9901
9902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
9903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9904 if (SWIG_arg_fail(1)) SWIG_fail;
9905 {
9906 PyThreadState* __tstate = wxPyBeginAllowThreads();
9907 result = ((wxFont const *)arg1)->GetFaceName();
9908
9909 wxPyEndAllowThreads(__tstate);
9910 if (PyErr_Occurred()) SWIG_fail;
9911 }
9912 {
9913 #if wxUSE_UNICODE
9914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9915 #else
9916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9917 #endif
9918 }
9919 return resultobj;
9920 fail:
9921 return NULL;
9922 }
9923
9924
9925 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9926 PyObject *resultobj;
9927 wxFont *arg1 = (wxFont *) 0 ;
9928 wxFontEncoding result;
9929 PyObject * obj0 = 0 ;
9930 char *kwnames[] = {
9931 (char *) "self", NULL
9932 };
9933
9934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
9935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9936 if (SWIG_arg_fail(1)) SWIG_fail;
9937 {
9938 PyThreadState* __tstate = wxPyBeginAllowThreads();
9939 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
9940
9941 wxPyEndAllowThreads(__tstate);
9942 if (PyErr_Occurred()) SWIG_fail;
9943 }
9944 resultobj = SWIG_From_int((result));
9945 return resultobj;
9946 fail:
9947 return NULL;
9948 }
9949
9950
9951 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9952 PyObject *resultobj;
9953 wxFont *arg1 = (wxFont *) 0 ;
9954 wxNativeFontInfo *result;
9955 PyObject * obj0 = 0 ;
9956 char *kwnames[] = {
9957 (char *) "self", NULL
9958 };
9959
9960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
9961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9962 if (SWIG_arg_fail(1)) SWIG_fail;
9963 {
9964 PyThreadState* __tstate = wxPyBeginAllowThreads();
9965 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
9966
9967 wxPyEndAllowThreads(__tstate);
9968 if (PyErr_Occurred()) SWIG_fail;
9969 }
9970 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
9971 return resultobj;
9972 fail:
9973 return NULL;
9974 }
9975
9976
9977 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
9978 PyObject *resultobj;
9979 wxFont *arg1 = (wxFont *) 0 ;
9980 bool result;
9981 PyObject * obj0 = 0 ;
9982 char *kwnames[] = {
9983 (char *) "self", NULL
9984 };
9985
9986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
9987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9988 if (SWIG_arg_fail(1)) SWIG_fail;
9989 {
9990 PyThreadState* __tstate = wxPyBeginAllowThreads();
9991 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
9992
9993 wxPyEndAllowThreads(__tstate);
9994 if (PyErr_Occurred()) SWIG_fail;
9995 }
9996 {
9997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9998 }
9999 return resultobj;
10000 fail:
10001 return NULL;
10002 }
10003
10004
10005 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10006 PyObject *resultobj;
10007 wxFont *arg1 = (wxFont *) 0 ;
10008 wxString result;
10009 PyObject * obj0 = 0 ;
10010 char *kwnames[] = {
10011 (char *) "self", NULL
10012 };
10013
10014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
10015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10016 if (SWIG_arg_fail(1)) SWIG_fail;
10017 {
10018 PyThreadState* __tstate = wxPyBeginAllowThreads();
10019 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
10020
10021 wxPyEndAllowThreads(__tstate);
10022 if (PyErr_Occurred()) SWIG_fail;
10023 }
10024 {
10025 #if wxUSE_UNICODE
10026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10027 #else
10028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10029 #endif
10030 }
10031 return resultobj;
10032 fail:
10033 return NULL;
10034 }
10035
10036
10037 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10038 PyObject *resultobj;
10039 wxFont *arg1 = (wxFont *) 0 ;
10040 wxString result;
10041 PyObject * obj0 = 0 ;
10042 char *kwnames[] = {
10043 (char *) "self", NULL
10044 };
10045
10046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
10047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10048 if (SWIG_arg_fail(1)) SWIG_fail;
10049 {
10050 PyThreadState* __tstate = wxPyBeginAllowThreads();
10051 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
10052
10053 wxPyEndAllowThreads(__tstate);
10054 if (PyErr_Occurred()) SWIG_fail;
10055 }
10056 {
10057 #if wxUSE_UNICODE
10058 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10059 #else
10060 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10061 #endif
10062 }
10063 return resultobj;
10064 fail:
10065 return NULL;
10066 }
10067
10068
10069 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10070 PyObject *resultobj;
10071 wxFont *arg1 = (wxFont *) 0 ;
10072 int arg2 ;
10073 PyObject * obj0 = 0 ;
10074 PyObject * obj1 = 0 ;
10075 char *kwnames[] = {
10076 (char *) "self",(char *) "pointSize", NULL
10077 };
10078
10079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
10080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10081 if (SWIG_arg_fail(1)) SWIG_fail;
10082 {
10083 arg2 = (int)(SWIG_As_int(obj1));
10084 if (SWIG_arg_fail(2)) SWIG_fail;
10085 }
10086 {
10087 PyThreadState* __tstate = wxPyBeginAllowThreads();
10088 (arg1)->SetPointSize(arg2);
10089
10090 wxPyEndAllowThreads(__tstate);
10091 if (PyErr_Occurred()) SWIG_fail;
10092 }
10093 Py_INCREF(Py_None); resultobj = Py_None;
10094 return resultobj;
10095 fail:
10096 return NULL;
10097 }
10098
10099
10100 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10101 PyObject *resultobj;
10102 wxFont *arg1 = (wxFont *) 0 ;
10103 wxSize *arg2 = 0 ;
10104 wxSize temp2 ;
10105 PyObject * obj0 = 0 ;
10106 PyObject * obj1 = 0 ;
10107 char *kwnames[] = {
10108 (char *) "self",(char *) "pixelSize", NULL
10109 };
10110
10111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10113 if (SWIG_arg_fail(1)) SWIG_fail;
10114 {
10115 arg2 = &temp2;
10116 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10117 }
10118 {
10119 PyThreadState* __tstate = wxPyBeginAllowThreads();
10120 (arg1)->SetPixelSize((wxSize const &)*arg2);
10121
10122 wxPyEndAllowThreads(__tstate);
10123 if (PyErr_Occurred()) SWIG_fail;
10124 }
10125 Py_INCREF(Py_None); resultobj = Py_None;
10126 return resultobj;
10127 fail:
10128 return NULL;
10129 }
10130
10131
10132 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10133 PyObject *resultobj;
10134 wxFont *arg1 = (wxFont *) 0 ;
10135 int arg2 ;
10136 PyObject * obj0 = 0 ;
10137 PyObject * obj1 = 0 ;
10138 char *kwnames[] = {
10139 (char *) "self",(char *) "family", NULL
10140 };
10141
10142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10144 if (SWIG_arg_fail(1)) SWIG_fail;
10145 {
10146 arg2 = (int)(SWIG_As_int(obj1));
10147 if (SWIG_arg_fail(2)) SWIG_fail;
10148 }
10149 {
10150 PyThreadState* __tstate = wxPyBeginAllowThreads();
10151 (arg1)->SetFamily(arg2);
10152
10153 wxPyEndAllowThreads(__tstate);
10154 if (PyErr_Occurred()) SWIG_fail;
10155 }
10156 Py_INCREF(Py_None); resultobj = Py_None;
10157 return resultobj;
10158 fail:
10159 return NULL;
10160 }
10161
10162
10163 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10164 PyObject *resultobj;
10165 wxFont *arg1 = (wxFont *) 0 ;
10166 int arg2 ;
10167 PyObject * obj0 = 0 ;
10168 PyObject * obj1 = 0 ;
10169 char *kwnames[] = {
10170 (char *) "self",(char *) "style", NULL
10171 };
10172
10173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10175 if (SWIG_arg_fail(1)) SWIG_fail;
10176 {
10177 arg2 = (int)(SWIG_As_int(obj1));
10178 if (SWIG_arg_fail(2)) SWIG_fail;
10179 }
10180 {
10181 PyThreadState* __tstate = wxPyBeginAllowThreads();
10182 (arg1)->SetStyle(arg2);
10183
10184 wxPyEndAllowThreads(__tstate);
10185 if (PyErr_Occurred()) SWIG_fail;
10186 }
10187 Py_INCREF(Py_None); resultobj = Py_None;
10188 return resultobj;
10189 fail:
10190 return NULL;
10191 }
10192
10193
10194 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10195 PyObject *resultobj;
10196 wxFont *arg1 = (wxFont *) 0 ;
10197 int arg2 ;
10198 PyObject * obj0 = 0 ;
10199 PyObject * obj1 = 0 ;
10200 char *kwnames[] = {
10201 (char *) "self",(char *) "weight", NULL
10202 };
10203
10204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10206 if (SWIG_arg_fail(1)) SWIG_fail;
10207 {
10208 arg2 = (int)(SWIG_As_int(obj1));
10209 if (SWIG_arg_fail(2)) SWIG_fail;
10210 }
10211 {
10212 PyThreadState* __tstate = wxPyBeginAllowThreads();
10213 (arg1)->SetWeight(arg2);
10214
10215 wxPyEndAllowThreads(__tstate);
10216 if (PyErr_Occurred()) SWIG_fail;
10217 }
10218 Py_INCREF(Py_None); resultobj = Py_None;
10219 return resultobj;
10220 fail:
10221 return NULL;
10222 }
10223
10224
10225 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10226 PyObject *resultobj;
10227 wxFont *arg1 = (wxFont *) 0 ;
10228 wxString *arg2 = 0 ;
10229 bool temp2 = false ;
10230 PyObject * obj0 = 0 ;
10231 PyObject * obj1 = 0 ;
10232 char *kwnames[] = {
10233 (char *) "self",(char *) "faceName", NULL
10234 };
10235
10236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10238 if (SWIG_arg_fail(1)) SWIG_fail;
10239 {
10240 arg2 = wxString_in_helper(obj1);
10241 if (arg2 == NULL) SWIG_fail;
10242 temp2 = true;
10243 }
10244 {
10245 PyThreadState* __tstate = wxPyBeginAllowThreads();
10246 (arg1)->SetFaceName((wxString const &)*arg2);
10247
10248 wxPyEndAllowThreads(__tstate);
10249 if (PyErr_Occurred()) SWIG_fail;
10250 }
10251 Py_INCREF(Py_None); resultobj = Py_None;
10252 {
10253 if (temp2)
10254 delete arg2;
10255 }
10256 return resultobj;
10257 fail:
10258 {
10259 if (temp2)
10260 delete arg2;
10261 }
10262 return NULL;
10263 }
10264
10265
10266 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10267 PyObject *resultobj;
10268 wxFont *arg1 = (wxFont *) 0 ;
10269 bool arg2 ;
10270 PyObject * obj0 = 0 ;
10271 PyObject * obj1 = 0 ;
10272 char *kwnames[] = {
10273 (char *) "self",(char *) "underlined", NULL
10274 };
10275
10276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10278 if (SWIG_arg_fail(1)) SWIG_fail;
10279 {
10280 arg2 = (bool)(SWIG_As_bool(obj1));
10281 if (SWIG_arg_fail(2)) SWIG_fail;
10282 }
10283 {
10284 PyThreadState* __tstate = wxPyBeginAllowThreads();
10285 (arg1)->SetUnderlined(arg2);
10286
10287 wxPyEndAllowThreads(__tstate);
10288 if (PyErr_Occurred()) SWIG_fail;
10289 }
10290 Py_INCREF(Py_None); resultobj = Py_None;
10291 return resultobj;
10292 fail:
10293 return NULL;
10294 }
10295
10296
10297 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10298 PyObject *resultobj;
10299 wxFont *arg1 = (wxFont *) 0 ;
10300 wxFontEncoding arg2 ;
10301 PyObject * obj0 = 0 ;
10302 PyObject * obj1 = 0 ;
10303 char *kwnames[] = {
10304 (char *) "self",(char *) "encoding", NULL
10305 };
10306
10307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10309 if (SWIG_arg_fail(1)) SWIG_fail;
10310 {
10311 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10312 if (SWIG_arg_fail(2)) SWIG_fail;
10313 }
10314 {
10315 PyThreadState* __tstate = wxPyBeginAllowThreads();
10316 (arg1)->SetEncoding((wxFontEncoding )arg2);
10317
10318 wxPyEndAllowThreads(__tstate);
10319 if (PyErr_Occurred()) SWIG_fail;
10320 }
10321 Py_INCREF(Py_None); resultobj = Py_None;
10322 return resultobj;
10323 fail:
10324 return NULL;
10325 }
10326
10327
10328 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10329 PyObject *resultobj;
10330 wxFont *arg1 = (wxFont *) 0 ;
10331 wxNativeFontInfo *arg2 = 0 ;
10332 PyObject * obj0 = 0 ;
10333 PyObject * obj1 = 0 ;
10334 char *kwnames[] = {
10335 (char *) "self",(char *) "info", NULL
10336 };
10337
10338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10340 if (SWIG_arg_fail(1)) SWIG_fail;
10341 {
10342 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10343 if (SWIG_arg_fail(2)) SWIG_fail;
10344 if (arg2 == NULL) {
10345 SWIG_null_ref("wxNativeFontInfo");
10346 }
10347 if (SWIG_arg_fail(2)) SWIG_fail;
10348 }
10349 {
10350 PyThreadState* __tstate = wxPyBeginAllowThreads();
10351 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10352
10353 wxPyEndAllowThreads(__tstate);
10354 if (PyErr_Occurred()) SWIG_fail;
10355 }
10356 Py_INCREF(Py_None); resultobj = Py_None;
10357 return resultobj;
10358 fail:
10359 return NULL;
10360 }
10361
10362
10363 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10364 PyObject *resultobj;
10365 wxFont *arg1 = (wxFont *) 0 ;
10366 wxString *arg2 = 0 ;
10367 bool temp2 = false ;
10368 PyObject * obj0 = 0 ;
10369 PyObject * obj1 = 0 ;
10370 char *kwnames[] = {
10371 (char *) "self",(char *) "info", NULL
10372 };
10373
10374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10376 if (SWIG_arg_fail(1)) SWIG_fail;
10377 {
10378 arg2 = wxString_in_helper(obj1);
10379 if (arg2 == NULL) SWIG_fail;
10380 temp2 = true;
10381 }
10382 {
10383 PyThreadState* __tstate = wxPyBeginAllowThreads();
10384 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10385
10386 wxPyEndAllowThreads(__tstate);
10387 if (PyErr_Occurred()) SWIG_fail;
10388 }
10389 Py_INCREF(Py_None); resultobj = Py_None;
10390 {
10391 if (temp2)
10392 delete arg2;
10393 }
10394 return resultobj;
10395 fail:
10396 {
10397 if (temp2)
10398 delete arg2;
10399 }
10400 return NULL;
10401 }
10402
10403
10404 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10405 PyObject *resultobj;
10406 wxFont *arg1 = (wxFont *) 0 ;
10407 wxString *arg2 = 0 ;
10408 bool temp2 = false ;
10409 PyObject * obj0 = 0 ;
10410 PyObject * obj1 = 0 ;
10411 char *kwnames[] = {
10412 (char *) "self",(char *) "info", NULL
10413 };
10414
10415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10417 if (SWIG_arg_fail(1)) SWIG_fail;
10418 {
10419 arg2 = wxString_in_helper(obj1);
10420 if (arg2 == NULL) SWIG_fail;
10421 temp2 = true;
10422 }
10423 {
10424 PyThreadState* __tstate = wxPyBeginAllowThreads();
10425 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
10426
10427 wxPyEndAllowThreads(__tstate);
10428 if (PyErr_Occurred()) SWIG_fail;
10429 }
10430 Py_INCREF(Py_None); resultobj = Py_None;
10431 {
10432 if (temp2)
10433 delete arg2;
10434 }
10435 return resultobj;
10436 fail:
10437 {
10438 if (temp2)
10439 delete arg2;
10440 }
10441 return NULL;
10442 }
10443
10444
10445 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
10446 PyObject *resultobj;
10447 wxFont *arg1 = (wxFont *) 0 ;
10448 wxString result;
10449 PyObject * obj0 = 0 ;
10450 char *kwnames[] = {
10451 (char *) "self", NULL
10452 };
10453
10454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
10455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10456 if (SWIG_arg_fail(1)) SWIG_fail;
10457 {
10458 PyThreadState* __tstate = wxPyBeginAllowThreads();
10459 result = ((wxFont const *)arg1)->GetFamilyString();
10460
10461 wxPyEndAllowThreads(__tstate);
10462 if (PyErr_Occurred()) SWIG_fail;
10463 }
10464 {
10465 #if wxUSE_UNICODE
10466 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10467 #else
10468 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10469 #endif
10470 }
10471 return resultobj;
10472 fail:
10473 return NULL;
10474 }
10475
10476
10477 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
10478 PyObject *resultobj;
10479 wxFont *arg1 = (wxFont *) 0 ;
10480 wxString result;
10481 PyObject * obj0 = 0 ;
10482 char *kwnames[] = {
10483 (char *) "self", NULL
10484 };
10485
10486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
10487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10488 if (SWIG_arg_fail(1)) SWIG_fail;
10489 {
10490 PyThreadState* __tstate = wxPyBeginAllowThreads();
10491 result = ((wxFont const *)arg1)->GetStyleString();
10492
10493 wxPyEndAllowThreads(__tstate);
10494 if (PyErr_Occurred()) SWIG_fail;
10495 }
10496 {
10497 #if wxUSE_UNICODE
10498 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10499 #else
10500 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10501 #endif
10502 }
10503 return resultobj;
10504 fail:
10505 return NULL;
10506 }
10507
10508
10509 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
10510 PyObject *resultobj;
10511 wxFont *arg1 = (wxFont *) 0 ;
10512 wxString result;
10513 PyObject * obj0 = 0 ;
10514 char *kwnames[] = {
10515 (char *) "self", NULL
10516 };
10517
10518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
10519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10520 if (SWIG_arg_fail(1)) SWIG_fail;
10521 {
10522 PyThreadState* __tstate = wxPyBeginAllowThreads();
10523 result = ((wxFont const *)arg1)->GetWeightString();
10524
10525 wxPyEndAllowThreads(__tstate);
10526 if (PyErr_Occurred()) SWIG_fail;
10527 }
10528 {
10529 #if wxUSE_UNICODE
10530 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10531 #else
10532 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10533 #endif
10534 }
10535 return resultobj;
10536 fail:
10537 return NULL;
10538 }
10539
10540
10541 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10542 PyObject *resultobj;
10543 wxFont *arg1 = (wxFont *) 0 ;
10544 bool arg2 = (bool) true ;
10545 PyObject * obj0 = 0 ;
10546 PyObject * obj1 = 0 ;
10547 char *kwnames[] = {
10548 (char *) "self",(char *) "no", NULL
10549 };
10550
10551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
10552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10553 if (SWIG_arg_fail(1)) SWIG_fail;
10554 if (obj1) {
10555 {
10556 arg2 = (bool)(SWIG_As_bool(obj1));
10557 if (SWIG_arg_fail(2)) SWIG_fail;
10558 }
10559 }
10560 {
10561 PyThreadState* __tstate = wxPyBeginAllowThreads();
10562 (arg1)->SetNoAntiAliasing(arg2);
10563
10564 wxPyEndAllowThreads(__tstate);
10565 if (PyErr_Occurred()) SWIG_fail;
10566 }
10567 Py_INCREF(Py_None); resultobj = Py_None;
10568 return resultobj;
10569 fail:
10570 return NULL;
10571 }
10572
10573
10574 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10575 PyObject *resultobj;
10576 wxFont *arg1 = (wxFont *) 0 ;
10577 bool result;
10578 PyObject * obj0 = 0 ;
10579 char *kwnames[] = {
10580 (char *) "self", NULL
10581 };
10582
10583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
10584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10585 if (SWIG_arg_fail(1)) SWIG_fail;
10586 {
10587 PyThreadState* __tstate = wxPyBeginAllowThreads();
10588 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
10589
10590 wxPyEndAllowThreads(__tstate);
10591 if (PyErr_Occurred()) SWIG_fail;
10592 }
10593 {
10594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10595 }
10596 return resultobj;
10597 fail:
10598 return NULL;
10599 }
10600
10601
10602 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10603 PyObject *resultobj;
10604 wxFontEncoding result;
10605 char *kwnames[] = {
10606 NULL
10607 };
10608
10609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
10610 {
10611 if (!wxPyCheckForApp()) SWIG_fail;
10612 PyThreadState* __tstate = wxPyBeginAllowThreads();
10613 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
10614
10615 wxPyEndAllowThreads(__tstate);
10616 if (PyErr_Occurred()) SWIG_fail;
10617 }
10618 resultobj = SWIG_From_int((result));
10619 return resultobj;
10620 fail:
10621 return NULL;
10622 }
10623
10624
10625 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10626 PyObject *resultobj;
10627 wxFontEncoding arg1 ;
10628 PyObject * obj0 = 0 ;
10629 char *kwnames[] = {
10630 (char *) "encoding", NULL
10631 };
10632
10633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
10634 {
10635 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
10636 if (SWIG_arg_fail(1)) SWIG_fail;
10637 }
10638 {
10639 if (!wxPyCheckForApp()) SWIG_fail;
10640 PyThreadState* __tstate = wxPyBeginAllowThreads();
10641 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
10642
10643 wxPyEndAllowThreads(__tstate);
10644 if (PyErr_Occurred()) SWIG_fail;
10645 }
10646 Py_INCREF(Py_None); resultobj = Py_None;
10647 return resultobj;
10648 fail:
10649 return NULL;
10650 }
10651
10652
10653 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
10654 PyObject *obj;
10655 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10656 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
10657 Py_INCREF(obj);
10658 return Py_BuildValue((char *)"");
10659 }
10660 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10661 PyObject *resultobj;
10662 wxPyFontEnumerator *result;
10663 char *kwnames[] = {
10664 NULL
10665 };
10666
10667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
10668 {
10669 if (!wxPyCheckForApp()) SWIG_fail;
10670 PyThreadState* __tstate = wxPyBeginAllowThreads();
10671 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
10672
10673 wxPyEndAllowThreads(__tstate);
10674 if (PyErr_Occurred()) SWIG_fail;
10675 }
10676 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
10677 return resultobj;
10678 fail:
10679 return NULL;
10680 }
10681
10682
10683 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10684 PyObject *resultobj;
10685 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10686 PyObject * obj0 = 0 ;
10687 char *kwnames[] = {
10688 (char *) "self", NULL
10689 };
10690
10691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
10692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10693 if (SWIG_arg_fail(1)) SWIG_fail;
10694 {
10695 PyThreadState* __tstate = wxPyBeginAllowThreads();
10696 delete arg1;
10697
10698 wxPyEndAllowThreads(__tstate);
10699 if (PyErr_Occurred()) SWIG_fail;
10700 }
10701 Py_INCREF(Py_None); resultobj = Py_None;
10702 return resultobj;
10703 fail:
10704 return NULL;
10705 }
10706
10707
10708 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10709 PyObject *resultobj;
10710 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10711 PyObject *arg2 = (PyObject *) 0 ;
10712 PyObject *arg3 = (PyObject *) 0 ;
10713 bool arg4 ;
10714 PyObject * obj0 = 0 ;
10715 PyObject * obj1 = 0 ;
10716 PyObject * obj2 = 0 ;
10717 PyObject * obj3 = 0 ;
10718 char *kwnames[] = {
10719 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10720 };
10721
10722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10724 if (SWIG_arg_fail(1)) SWIG_fail;
10725 arg2 = obj1;
10726 arg3 = obj2;
10727 {
10728 arg4 = (bool)(SWIG_As_bool(obj3));
10729 if (SWIG_arg_fail(4)) SWIG_fail;
10730 }
10731 {
10732 PyThreadState* __tstate = wxPyBeginAllowThreads();
10733 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10734
10735 wxPyEndAllowThreads(__tstate);
10736 if (PyErr_Occurred()) SWIG_fail;
10737 }
10738 Py_INCREF(Py_None); resultobj = Py_None;
10739 return resultobj;
10740 fail:
10741 return NULL;
10742 }
10743
10744
10745 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10746 PyObject *resultobj;
10747 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10748 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
10749 bool arg3 = (bool) false ;
10750 bool result;
10751 PyObject * obj0 = 0 ;
10752 PyObject * obj1 = 0 ;
10753 PyObject * obj2 = 0 ;
10754 char *kwnames[] = {
10755 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
10756 };
10757
10758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
10759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10760 if (SWIG_arg_fail(1)) SWIG_fail;
10761 if (obj1) {
10762 {
10763 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10764 if (SWIG_arg_fail(2)) SWIG_fail;
10765 }
10766 }
10767 if (obj2) {
10768 {
10769 arg3 = (bool)(SWIG_As_bool(obj2));
10770 if (SWIG_arg_fail(3)) SWIG_fail;
10771 }
10772 }
10773 {
10774 PyThreadState* __tstate = wxPyBeginAllowThreads();
10775 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
10776
10777 wxPyEndAllowThreads(__tstate);
10778 if (PyErr_Occurred()) SWIG_fail;
10779 }
10780 {
10781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10782 }
10783 return resultobj;
10784 fail:
10785 return NULL;
10786 }
10787
10788
10789 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10790 PyObject *resultobj;
10791 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10792 wxString const &arg2_defvalue = wxPyEmptyString ;
10793 wxString *arg2 = (wxString *) &arg2_defvalue ;
10794 bool result;
10795 bool temp2 = false ;
10796 PyObject * obj0 = 0 ;
10797 PyObject * obj1 = 0 ;
10798 char *kwnames[] = {
10799 (char *) "self",(char *) "facename", NULL
10800 };
10801
10802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
10803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10804 if (SWIG_arg_fail(1)) SWIG_fail;
10805 if (obj1) {
10806 {
10807 arg2 = wxString_in_helper(obj1);
10808 if (arg2 == NULL) SWIG_fail;
10809 temp2 = true;
10810 }
10811 }
10812 {
10813 PyThreadState* __tstate = wxPyBeginAllowThreads();
10814 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
10815
10816 wxPyEndAllowThreads(__tstate);
10817 if (PyErr_Occurred()) SWIG_fail;
10818 }
10819 {
10820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10821 }
10822 {
10823 if (temp2)
10824 delete arg2;
10825 }
10826 return resultobj;
10827 fail:
10828 {
10829 if (temp2)
10830 delete arg2;
10831 }
10832 return NULL;
10833 }
10834
10835
10836 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10837 PyObject *resultobj;
10838 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10839 PyObject *result;
10840 PyObject * obj0 = 0 ;
10841 char *kwnames[] = {
10842 (char *) "self", NULL
10843 };
10844
10845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
10846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10847 if (SWIG_arg_fail(1)) SWIG_fail;
10848 {
10849 PyThreadState* __tstate = wxPyBeginAllowThreads();
10850 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
10851
10852 wxPyEndAllowThreads(__tstate);
10853 if (PyErr_Occurred()) SWIG_fail;
10854 }
10855 resultobj = result;
10856 return resultobj;
10857 fail:
10858 return NULL;
10859 }
10860
10861
10862 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10863 PyObject *resultobj;
10864 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10865 PyObject *result;
10866 PyObject * obj0 = 0 ;
10867 char *kwnames[] = {
10868 (char *) "self", NULL
10869 };
10870
10871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
10872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10873 if (SWIG_arg_fail(1)) SWIG_fail;
10874 {
10875 PyThreadState* __tstate = wxPyBeginAllowThreads();
10876 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
10877
10878 wxPyEndAllowThreads(__tstate);
10879 if (PyErr_Occurred()) SWIG_fail;
10880 }
10881 resultobj = result;
10882 return resultobj;
10883 fail:
10884 return NULL;
10885 }
10886
10887
10888 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
10889 PyObject *obj;
10890 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10891 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
10892 Py_INCREF(obj);
10893 return Py_BuildValue((char *)"");
10894 }
10895 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
10896 PyObject *resultobj;
10897 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10898 int arg2 ;
10899 PyObject * obj0 = 0 ;
10900 PyObject * obj1 = 0 ;
10901 char *kwnames[] = {
10902 (char *) "self",(char *) "Language", NULL
10903 };
10904
10905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
10906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10907 if (SWIG_arg_fail(1)) SWIG_fail;
10908 {
10909 arg2 = (int)(SWIG_As_int(obj1));
10910 if (SWIG_arg_fail(2)) SWIG_fail;
10911 }
10912 if (arg1) (arg1)->Language = arg2;
10913
10914 Py_INCREF(Py_None); resultobj = Py_None;
10915 return resultobj;
10916 fail:
10917 return NULL;
10918 }
10919
10920
10921 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
10922 PyObject *resultobj;
10923 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10924 int result;
10925 PyObject * obj0 = 0 ;
10926 char *kwnames[] = {
10927 (char *) "self", NULL
10928 };
10929
10930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
10931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10932 if (SWIG_arg_fail(1)) SWIG_fail;
10933 result = (int) ((arg1)->Language);
10934
10935 {
10936 resultobj = SWIG_From_int((int)(result));
10937 }
10938 return resultobj;
10939 fail:
10940 return NULL;
10941 }
10942
10943
10944 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
10945 PyObject *resultobj;
10946 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10947 wxString *arg2 = (wxString *) 0 ;
10948 bool temp2 = false ;
10949 PyObject * obj0 = 0 ;
10950 PyObject * obj1 = 0 ;
10951 char *kwnames[] = {
10952 (char *) "self",(char *) "CanonicalName", NULL
10953 };
10954
10955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
10956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10957 if (SWIG_arg_fail(1)) SWIG_fail;
10958 {
10959 arg2 = wxString_in_helper(obj1);
10960 if (arg2 == NULL) SWIG_fail;
10961 temp2 = true;
10962 }
10963 if (arg1) (arg1)->CanonicalName = *arg2;
10964
10965 Py_INCREF(Py_None); resultobj = Py_None;
10966 {
10967 if (temp2)
10968 delete arg2;
10969 }
10970 return resultobj;
10971 fail:
10972 {
10973 if (temp2)
10974 delete arg2;
10975 }
10976 return NULL;
10977 }
10978
10979
10980 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
10981 PyObject *resultobj;
10982 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10983 wxString *result;
10984 PyObject * obj0 = 0 ;
10985 char *kwnames[] = {
10986 (char *) "self", NULL
10987 };
10988
10989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
10990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10991 if (SWIG_arg_fail(1)) SWIG_fail;
10992 result = (wxString *)& ((arg1)->CanonicalName);
10993
10994 {
10995 #if wxUSE_UNICODE
10996 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10997 #else
10998 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10999 #endif
11000 }
11001 return resultobj;
11002 fail:
11003 return NULL;
11004 }
11005
11006
11007 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
11008 PyObject *resultobj;
11009 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11010 wxString *arg2 = (wxString *) 0 ;
11011 bool temp2 = false ;
11012 PyObject * obj0 = 0 ;
11013 PyObject * obj1 = 0 ;
11014 char *kwnames[] = {
11015 (char *) "self",(char *) "Description", NULL
11016 };
11017
11018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
11019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11020 if (SWIG_arg_fail(1)) SWIG_fail;
11021 {
11022 arg2 = wxString_in_helper(obj1);
11023 if (arg2 == NULL) SWIG_fail;
11024 temp2 = true;
11025 }
11026 if (arg1) (arg1)->Description = *arg2;
11027
11028 Py_INCREF(Py_None); resultobj = Py_None;
11029 {
11030 if (temp2)
11031 delete arg2;
11032 }
11033 return resultobj;
11034 fail:
11035 {
11036 if (temp2)
11037 delete arg2;
11038 }
11039 return NULL;
11040 }
11041
11042
11043 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
11044 PyObject *resultobj;
11045 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11046 wxString *result;
11047 PyObject * obj0 = 0 ;
11048 char *kwnames[] = {
11049 (char *) "self", NULL
11050 };
11051
11052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
11053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11054 if (SWIG_arg_fail(1)) SWIG_fail;
11055 result = (wxString *)& ((arg1)->Description);
11056
11057 {
11058 #if wxUSE_UNICODE
11059 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11060 #else
11061 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11062 #endif
11063 }
11064 return resultobj;
11065 fail:
11066 return NULL;
11067 }
11068
11069
11070 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
11071 PyObject *obj;
11072 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11073 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
11074 Py_INCREF(obj);
11075 return Py_BuildValue((char *)"");
11076 }
11077 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11078 PyObject *resultobj;
11079 int arg1 = (int) -1 ;
11080 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11081 wxLocale *result;
11082 PyObject * obj0 = 0 ;
11083 PyObject * obj1 = 0 ;
11084 char *kwnames[] = {
11085 (char *) "language",(char *) "flags", NULL
11086 };
11087
11088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
11089 if (obj0) {
11090 {
11091 arg1 = (int)(SWIG_As_int(obj0));
11092 if (SWIG_arg_fail(1)) SWIG_fail;
11093 }
11094 }
11095 if (obj1) {
11096 {
11097 arg2 = (int)(SWIG_As_int(obj1));
11098 if (SWIG_arg_fail(2)) SWIG_fail;
11099 }
11100 }
11101 {
11102 PyThreadState* __tstate = wxPyBeginAllowThreads();
11103 result = (wxLocale *)new_wxLocale(arg1,arg2);
11104
11105 wxPyEndAllowThreads(__tstate);
11106 if (PyErr_Occurred()) SWIG_fail;
11107 }
11108 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11109 return resultobj;
11110 fail:
11111 return NULL;
11112 }
11113
11114
11115 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11116 PyObject *resultobj;
11117 wxLocale *arg1 = (wxLocale *) 0 ;
11118 PyObject * obj0 = 0 ;
11119 char *kwnames[] = {
11120 (char *) "self", NULL
11121 };
11122
11123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11125 if (SWIG_arg_fail(1)) SWIG_fail;
11126 {
11127 PyThreadState* __tstate = wxPyBeginAllowThreads();
11128 delete arg1;
11129
11130 wxPyEndAllowThreads(__tstate);
11131 if (PyErr_Occurred()) SWIG_fail;
11132 }
11133 Py_INCREF(Py_None); resultobj = Py_None;
11134 return resultobj;
11135 fail:
11136 return NULL;
11137 }
11138
11139
11140 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11141 PyObject *resultobj;
11142 wxLocale *arg1 = (wxLocale *) 0 ;
11143 wxString *arg2 = 0 ;
11144 wxString const &arg3_defvalue = wxPyEmptyString ;
11145 wxString *arg3 = (wxString *) &arg3_defvalue ;
11146 wxString const &arg4_defvalue = wxPyEmptyString ;
11147 wxString *arg4 = (wxString *) &arg4_defvalue ;
11148 bool arg5 = (bool) true ;
11149 bool arg6 = (bool) false ;
11150 bool result;
11151 bool temp2 = false ;
11152 bool temp3 = false ;
11153 bool temp4 = false ;
11154 PyObject * obj0 = 0 ;
11155 PyObject * obj1 = 0 ;
11156 PyObject * obj2 = 0 ;
11157 PyObject * obj3 = 0 ;
11158 PyObject * obj4 = 0 ;
11159 PyObject * obj5 = 0 ;
11160 char *kwnames[] = {
11161 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11162 };
11163
11164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11166 if (SWIG_arg_fail(1)) SWIG_fail;
11167 {
11168 arg2 = wxString_in_helper(obj1);
11169 if (arg2 == NULL) SWIG_fail;
11170 temp2 = true;
11171 }
11172 if (obj2) {
11173 {
11174 arg3 = wxString_in_helper(obj2);
11175 if (arg3 == NULL) SWIG_fail;
11176 temp3 = true;
11177 }
11178 }
11179 if (obj3) {
11180 {
11181 arg4 = wxString_in_helper(obj3);
11182 if (arg4 == NULL) SWIG_fail;
11183 temp4 = true;
11184 }
11185 }
11186 if (obj4) {
11187 {
11188 arg5 = (bool)(SWIG_As_bool(obj4));
11189 if (SWIG_arg_fail(5)) SWIG_fail;
11190 }
11191 }
11192 if (obj5) {
11193 {
11194 arg6 = (bool)(SWIG_As_bool(obj5));
11195 if (SWIG_arg_fail(6)) SWIG_fail;
11196 }
11197 }
11198 {
11199 PyThreadState* __tstate = wxPyBeginAllowThreads();
11200 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11201
11202 wxPyEndAllowThreads(__tstate);
11203 if (PyErr_Occurred()) SWIG_fail;
11204 }
11205 {
11206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11207 }
11208 {
11209 if (temp2)
11210 delete arg2;
11211 }
11212 {
11213 if (temp3)
11214 delete arg3;
11215 }
11216 {
11217 if (temp4)
11218 delete arg4;
11219 }
11220 return resultobj;
11221 fail:
11222 {
11223 if (temp2)
11224 delete arg2;
11225 }
11226 {
11227 if (temp3)
11228 delete arg3;
11229 }
11230 {
11231 if (temp4)
11232 delete arg4;
11233 }
11234 return NULL;
11235 }
11236
11237
11238 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11239 PyObject *resultobj;
11240 wxLocale *arg1 = (wxLocale *) 0 ;
11241 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11242 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11243 bool result;
11244 PyObject * obj0 = 0 ;
11245 PyObject * obj1 = 0 ;
11246 PyObject * obj2 = 0 ;
11247 char *kwnames[] = {
11248 (char *) "self",(char *) "language",(char *) "flags", NULL
11249 };
11250
11251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11253 if (SWIG_arg_fail(1)) SWIG_fail;
11254 if (obj1) {
11255 {
11256 arg2 = (int)(SWIG_As_int(obj1));
11257 if (SWIG_arg_fail(2)) SWIG_fail;
11258 }
11259 }
11260 if (obj2) {
11261 {
11262 arg3 = (int)(SWIG_As_int(obj2));
11263 if (SWIG_arg_fail(3)) SWIG_fail;
11264 }
11265 }
11266 {
11267 PyThreadState* __tstate = wxPyBeginAllowThreads();
11268 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11269
11270 wxPyEndAllowThreads(__tstate);
11271 if (PyErr_Occurred()) SWIG_fail;
11272 }
11273 {
11274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11275 }
11276 return resultobj;
11277 fail:
11278 return NULL;
11279 }
11280
11281
11282 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11283 PyObject *resultobj;
11284 int result;
11285 char *kwnames[] = {
11286 NULL
11287 };
11288
11289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11290 {
11291 PyThreadState* __tstate = wxPyBeginAllowThreads();
11292 result = (int)wxLocale::GetSystemLanguage();
11293
11294 wxPyEndAllowThreads(__tstate);
11295 if (PyErr_Occurred()) SWIG_fail;
11296 }
11297 {
11298 resultobj = SWIG_From_int((int)(result));
11299 }
11300 return resultobj;
11301 fail:
11302 return NULL;
11303 }
11304
11305
11306 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11307 PyObject *resultobj;
11308 wxFontEncoding result;
11309 char *kwnames[] = {
11310 NULL
11311 };
11312
11313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11314 {
11315 PyThreadState* __tstate = wxPyBeginAllowThreads();
11316 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11317
11318 wxPyEndAllowThreads(__tstate);
11319 if (PyErr_Occurred()) SWIG_fail;
11320 }
11321 resultobj = SWIG_From_int((result));
11322 return resultobj;
11323 fail:
11324 return NULL;
11325 }
11326
11327
11328 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11329 PyObject *resultobj;
11330 wxString result;
11331 char *kwnames[] = {
11332 NULL
11333 };
11334
11335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11336 {
11337 PyThreadState* __tstate = wxPyBeginAllowThreads();
11338 result = wxLocale::GetSystemEncodingName();
11339
11340 wxPyEndAllowThreads(__tstate);
11341 if (PyErr_Occurred()) SWIG_fail;
11342 }
11343 {
11344 #if wxUSE_UNICODE
11345 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11346 #else
11347 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11348 #endif
11349 }
11350 return resultobj;
11351 fail:
11352 return NULL;
11353 }
11354
11355
11356 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11357 PyObject *resultobj;
11358 wxLocale *arg1 = (wxLocale *) 0 ;
11359 bool result;
11360 PyObject * obj0 = 0 ;
11361 char *kwnames[] = {
11362 (char *) "self", NULL
11363 };
11364
11365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11367 if (SWIG_arg_fail(1)) SWIG_fail;
11368 {
11369 PyThreadState* __tstate = wxPyBeginAllowThreads();
11370 result = (bool)((wxLocale const *)arg1)->IsOk();
11371
11372 wxPyEndAllowThreads(__tstate);
11373 if (PyErr_Occurred()) SWIG_fail;
11374 }
11375 {
11376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11377 }
11378 return resultobj;
11379 fail:
11380 return NULL;
11381 }
11382
11383
11384 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11385 PyObject *resultobj;
11386 wxLocale *arg1 = (wxLocale *) 0 ;
11387 wxString result;
11388 PyObject * obj0 = 0 ;
11389 char *kwnames[] = {
11390 (char *) "self", NULL
11391 };
11392
11393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11395 if (SWIG_arg_fail(1)) SWIG_fail;
11396 {
11397 PyThreadState* __tstate = wxPyBeginAllowThreads();
11398 result = ((wxLocale const *)arg1)->GetLocale();
11399
11400 wxPyEndAllowThreads(__tstate);
11401 if (PyErr_Occurred()) SWIG_fail;
11402 }
11403 {
11404 #if wxUSE_UNICODE
11405 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11406 #else
11407 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11408 #endif
11409 }
11410 return resultobj;
11411 fail:
11412 return NULL;
11413 }
11414
11415
11416 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11417 PyObject *resultobj;
11418 wxLocale *arg1 = (wxLocale *) 0 ;
11419 int result;
11420 PyObject * obj0 = 0 ;
11421 char *kwnames[] = {
11422 (char *) "self", NULL
11423 };
11424
11425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
11426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11427 if (SWIG_arg_fail(1)) SWIG_fail;
11428 {
11429 PyThreadState* __tstate = wxPyBeginAllowThreads();
11430 result = (int)((wxLocale const *)arg1)->GetLanguage();
11431
11432 wxPyEndAllowThreads(__tstate);
11433 if (PyErr_Occurred()) SWIG_fail;
11434 }
11435 {
11436 resultobj = SWIG_From_int((int)(result));
11437 }
11438 return resultobj;
11439 fail:
11440 return NULL;
11441 }
11442
11443
11444 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
11445 PyObject *resultobj;
11446 wxLocale *arg1 = (wxLocale *) 0 ;
11447 wxString result;
11448 PyObject * obj0 = 0 ;
11449 char *kwnames[] = {
11450 (char *) "self", NULL
11451 };
11452
11453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
11454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11455 if (SWIG_arg_fail(1)) SWIG_fail;
11456 {
11457 PyThreadState* __tstate = wxPyBeginAllowThreads();
11458 result = ((wxLocale const *)arg1)->GetSysName();
11459
11460 wxPyEndAllowThreads(__tstate);
11461 if (PyErr_Occurred()) SWIG_fail;
11462 }
11463 {
11464 #if wxUSE_UNICODE
11465 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11466 #else
11467 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11468 #endif
11469 }
11470 return resultobj;
11471 fail:
11472 return NULL;
11473 }
11474
11475
11476 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
11477 PyObject *resultobj;
11478 wxLocale *arg1 = (wxLocale *) 0 ;
11479 wxString result;
11480 PyObject * obj0 = 0 ;
11481 char *kwnames[] = {
11482 (char *) "self", NULL
11483 };
11484
11485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
11486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11487 if (SWIG_arg_fail(1)) SWIG_fail;
11488 {
11489 PyThreadState* __tstate = wxPyBeginAllowThreads();
11490 result = ((wxLocale const *)arg1)->GetCanonicalName();
11491
11492 wxPyEndAllowThreads(__tstate);
11493 if (PyErr_Occurred()) SWIG_fail;
11494 }
11495 {
11496 #if wxUSE_UNICODE
11497 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11498 #else
11499 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11500 #endif
11501 }
11502 return resultobj;
11503 fail:
11504 return NULL;
11505 }
11506
11507
11508 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
11509 PyObject *resultobj;
11510 wxString *arg1 = 0 ;
11511 bool temp1 = false ;
11512 PyObject * obj0 = 0 ;
11513 char *kwnames[] = {
11514 (char *) "prefix", NULL
11515 };
11516
11517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
11518 {
11519 arg1 = wxString_in_helper(obj0);
11520 if (arg1 == NULL) SWIG_fail;
11521 temp1 = true;
11522 }
11523 {
11524 PyThreadState* __tstate = wxPyBeginAllowThreads();
11525 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
11526
11527 wxPyEndAllowThreads(__tstate);
11528 if (PyErr_Occurred()) SWIG_fail;
11529 }
11530 Py_INCREF(Py_None); resultobj = Py_None;
11531 {
11532 if (temp1)
11533 delete arg1;
11534 }
11535 return resultobj;
11536 fail:
11537 {
11538 if (temp1)
11539 delete arg1;
11540 }
11541 return NULL;
11542 }
11543
11544
11545 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
11546 PyObject *resultobj;
11547 wxLocale *arg1 = (wxLocale *) 0 ;
11548 wxString *arg2 = 0 ;
11549 bool result;
11550 bool temp2 = false ;
11551 PyObject * obj0 = 0 ;
11552 PyObject * obj1 = 0 ;
11553 char *kwnames[] = {
11554 (char *) "self",(char *) "szDomain", NULL
11555 };
11556
11557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
11558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11559 if (SWIG_arg_fail(1)) SWIG_fail;
11560 {
11561 arg2 = wxString_in_helper(obj1);
11562 if (arg2 == NULL) SWIG_fail;
11563 temp2 = true;
11564 }
11565 {
11566 PyThreadState* __tstate = wxPyBeginAllowThreads();
11567 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
11568
11569 wxPyEndAllowThreads(__tstate);
11570 if (PyErr_Occurred()) SWIG_fail;
11571 }
11572 {
11573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11574 }
11575 {
11576 if (temp2)
11577 delete arg2;
11578 }
11579 return resultobj;
11580 fail:
11581 {
11582 if (temp2)
11583 delete arg2;
11584 }
11585 return NULL;
11586 }
11587
11588
11589 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
11590 PyObject *resultobj;
11591 wxLocale *arg1 = (wxLocale *) 0 ;
11592 wxString *arg2 = 0 ;
11593 bool result;
11594 bool temp2 = false ;
11595 PyObject * obj0 = 0 ;
11596 PyObject * obj1 = 0 ;
11597 char *kwnames[] = {
11598 (char *) "self",(char *) "szDomain", NULL
11599 };
11600
11601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
11602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11603 if (SWIG_arg_fail(1)) SWIG_fail;
11604 {
11605 arg2 = wxString_in_helper(obj1);
11606 if (arg2 == NULL) SWIG_fail;
11607 temp2 = true;
11608 }
11609 {
11610 PyThreadState* __tstate = wxPyBeginAllowThreads();
11611 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
11612
11613 wxPyEndAllowThreads(__tstate);
11614 if (PyErr_Occurred()) SWIG_fail;
11615 }
11616 {
11617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11618 }
11619 {
11620 if (temp2)
11621 delete arg2;
11622 }
11623 return resultobj;
11624 fail:
11625 {
11626 if (temp2)
11627 delete arg2;
11628 }
11629 return NULL;
11630 }
11631
11632
11633 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11634 PyObject *resultobj;
11635 int arg1 ;
11636 wxLanguageInfo *result;
11637 PyObject * obj0 = 0 ;
11638 char *kwnames[] = {
11639 (char *) "lang", NULL
11640 };
11641
11642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
11643 {
11644 arg1 = (int)(SWIG_As_int(obj0));
11645 if (SWIG_arg_fail(1)) SWIG_fail;
11646 }
11647 {
11648 PyThreadState* __tstate = wxPyBeginAllowThreads();
11649 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
11650
11651 wxPyEndAllowThreads(__tstate);
11652 if (PyErr_Occurred()) SWIG_fail;
11653 }
11654 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11655 return resultobj;
11656 fail:
11657 return NULL;
11658 }
11659
11660
11661 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
11662 PyObject *resultobj;
11663 int arg1 ;
11664 wxString result;
11665 PyObject * obj0 = 0 ;
11666 char *kwnames[] = {
11667 (char *) "lang", NULL
11668 };
11669
11670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
11671 {
11672 arg1 = (int)(SWIG_As_int(obj0));
11673 if (SWIG_arg_fail(1)) SWIG_fail;
11674 }
11675 {
11676 PyThreadState* __tstate = wxPyBeginAllowThreads();
11677 result = wxLocale::GetLanguageName(arg1);
11678
11679 wxPyEndAllowThreads(__tstate);
11680 if (PyErr_Occurred()) SWIG_fail;
11681 }
11682 {
11683 #if wxUSE_UNICODE
11684 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11685 #else
11686 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11687 #endif
11688 }
11689 return resultobj;
11690 fail:
11691 return NULL;
11692 }
11693
11694
11695 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11696 PyObject *resultobj;
11697 wxString *arg1 = 0 ;
11698 wxLanguageInfo *result;
11699 bool temp1 = false ;
11700 PyObject * obj0 = 0 ;
11701 char *kwnames[] = {
11702 (char *) "locale", NULL
11703 };
11704
11705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
11706 {
11707 arg1 = wxString_in_helper(obj0);
11708 if (arg1 == NULL) SWIG_fail;
11709 temp1 = true;
11710 }
11711 {
11712 PyThreadState* __tstate = wxPyBeginAllowThreads();
11713 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
11714
11715 wxPyEndAllowThreads(__tstate);
11716 if (PyErr_Occurred()) SWIG_fail;
11717 }
11718 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11719 {
11720 if (temp1)
11721 delete arg1;
11722 }
11723 return resultobj;
11724 fail:
11725 {
11726 if (temp1)
11727 delete arg1;
11728 }
11729 return NULL;
11730 }
11731
11732
11733 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11734 PyObject *resultobj;
11735 wxLanguageInfo *arg1 = 0 ;
11736 PyObject * obj0 = 0 ;
11737 char *kwnames[] = {
11738 (char *) "info", NULL
11739 };
11740
11741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
11742 {
11743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11744 if (SWIG_arg_fail(1)) SWIG_fail;
11745 if (arg1 == NULL) {
11746 SWIG_null_ref("wxLanguageInfo");
11747 }
11748 if (SWIG_arg_fail(1)) SWIG_fail;
11749 }
11750 {
11751 PyThreadState* __tstate = wxPyBeginAllowThreads();
11752 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
11753
11754 wxPyEndAllowThreads(__tstate);
11755 if (PyErr_Occurred()) SWIG_fail;
11756 }
11757 Py_INCREF(Py_None); resultobj = Py_None;
11758 return resultobj;
11759 fail:
11760 return NULL;
11761 }
11762
11763
11764 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
11765 PyObject *resultobj;
11766 wxLocale *arg1 = (wxLocale *) 0 ;
11767 wxString *arg2 = 0 ;
11768 wxString const &arg3_defvalue = wxPyEmptyString ;
11769 wxString *arg3 = (wxString *) &arg3_defvalue ;
11770 wxString result;
11771 bool temp2 = false ;
11772 bool temp3 = false ;
11773 PyObject * obj0 = 0 ;
11774 PyObject * obj1 = 0 ;
11775 PyObject * obj2 = 0 ;
11776 char *kwnames[] = {
11777 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
11778 };
11779
11780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
11781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11782 if (SWIG_arg_fail(1)) SWIG_fail;
11783 {
11784 arg2 = wxString_in_helper(obj1);
11785 if (arg2 == NULL) SWIG_fail;
11786 temp2 = true;
11787 }
11788 if (obj2) {
11789 {
11790 arg3 = wxString_in_helper(obj2);
11791 if (arg3 == NULL) SWIG_fail;
11792 temp3 = true;
11793 }
11794 }
11795 {
11796 PyThreadState* __tstate = wxPyBeginAllowThreads();
11797 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
11798
11799 wxPyEndAllowThreads(__tstate);
11800 if (PyErr_Occurred()) SWIG_fail;
11801 }
11802 {
11803 #if wxUSE_UNICODE
11804 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11805 #else
11806 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11807 #endif
11808 }
11809 {
11810 if (temp2)
11811 delete arg2;
11812 }
11813 {
11814 if (temp3)
11815 delete arg3;
11816 }
11817 return resultobj;
11818 fail:
11819 {
11820 if (temp2)
11821 delete arg2;
11822 }
11823 {
11824 if (temp3)
11825 delete arg3;
11826 }
11827 return NULL;
11828 }
11829
11830
11831 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
11832 PyObject *resultobj;
11833 wxLocale *arg1 = (wxLocale *) 0 ;
11834 wxString *result;
11835 PyObject * obj0 = 0 ;
11836 char *kwnames[] = {
11837 (char *) "self", NULL
11838 };
11839
11840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
11841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11842 if (SWIG_arg_fail(1)) SWIG_fail;
11843 {
11844 PyThreadState* __tstate = wxPyBeginAllowThreads();
11845 {
11846 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
11847 result = (wxString *) &_result_ref;
11848 }
11849
11850 wxPyEndAllowThreads(__tstate);
11851 if (PyErr_Occurred()) SWIG_fail;
11852 }
11853 {
11854 #if wxUSE_UNICODE
11855 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11856 #else
11857 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11858 #endif
11859 }
11860 return resultobj;
11861 fail:
11862 return NULL;
11863 }
11864
11865
11866 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
11867 PyObject *obj;
11868 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11869 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
11870 Py_INCREF(obj);
11871 return Py_BuildValue((char *)"");
11872 }
11873 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11874 PyObject *resultobj;
11875 wxLocale *result;
11876 char *kwnames[] = {
11877 NULL
11878 };
11879
11880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
11881 {
11882 PyThreadState* __tstate = wxPyBeginAllowThreads();
11883 result = (wxLocale *)wxGetLocale();
11884
11885 wxPyEndAllowThreads(__tstate);
11886 if (PyErr_Occurred()) SWIG_fail;
11887 }
11888 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
11889 return resultobj;
11890 fail:
11891 return NULL;
11892 }
11893
11894
11895 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
11896 PyObject *resultobj;
11897 wxString *arg1 = 0 ;
11898 wxString result;
11899 bool temp1 = false ;
11900 PyObject * obj0 = 0 ;
11901
11902 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
11903 {
11904 arg1 = wxString_in_helper(obj0);
11905 if (arg1 == NULL) SWIG_fail;
11906 temp1 = true;
11907 }
11908 {
11909 PyThreadState* __tstate = wxPyBeginAllowThreads();
11910 result = wxGetTranslation((wxString const &)*arg1);
11911
11912 wxPyEndAllowThreads(__tstate);
11913 if (PyErr_Occurred()) SWIG_fail;
11914 }
11915 {
11916 #if wxUSE_UNICODE
11917 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11918 #else
11919 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11920 #endif
11921 }
11922 {
11923 if (temp1)
11924 delete arg1;
11925 }
11926 return resultobj;
11927 fail:
11928 {
11929 if (temp1)
11930 delete arg1;
11931 }
11932 return NULL;
11933 }
11934
11935
11936 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
11937 PyObject *resultobj;
11938 wxString *arg1 = 0 ;
11939 wxString *arg2 = 0 ;
11940 size_t arg3 ;
11941 wxString result;
11942 bool temp1 = false ;
11943 bool temp2 = false ;
11944 PyObject * obj0 = 0 ;
11945 PyObject * obj1 = 0 ;
11946 PyObject * obj2 = 0 ;
11947
11948 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
11949 {
11950 arg1 = wxString_in_helper(obj0);
11951 if (arg1 == NULL) SWIG_fail;
11952 temp1 = true;
11953 }
11954 {
11955 arg2 = wxString_in_helper(obj1);
11956 if (arg2 == NULL) SWIG_fail;
11957 temp2 = true;
11958 }
11959 {
11960 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
11961 if (SWIG_arg_fail(3)) SWIG_fail;
11962 }
11963 {
11964 PyThreadState* __tstate = wxPyBeginAllowThreads();
11965 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11966
11967 wxPyEndAllowThreads(__tstate);
11968 if (PyErr_Occurred()) SWIG_fail;
11969 }
11970 {
11971 #if wxUSE_UNICODE
11972 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11973 #else
11974 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11975 #endif
11976 }
11977 {
11978 if (temp1)
11979 delete arg1;
11980 }
11981 {
11982 if (temp2)
11983 delete arg2;
11984 }
11985 return resultobj;
11986 fail:
11987 {
11988 if (temp1)
11989 delete arg1;
11990 }
11991 {
11992 if (temp2)
11993 delete arg2;
11994 }
11995 return NULL;
11996 }
11997
11998
11999 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
12000 int argc;
12001 PyObject *argv[4];
12002 int ii;
12003
12004 argc = PyObject_Length(args);
12005 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
12006 argv[ii] = PyTuple_GetItem(args,ii);
12007 }
12008 if (argc == 1) {
12009 int _v;
12010 {
12011 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12012 }
12013 if (_v) {
12014 return _wrap_GetTranslation__SWIG_0(self,args);
12015 }
12016 }
12017 if (argc == 3) {
12018 int _v;
12019 {
12020 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12021 }
12022 if (_v) {
12023 {
12024 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
12025 }
12026 if (_v) {
12027 _v = SWIG_Check_unsigned_SS_long(argv[2]);
12028 if (_v) {
12029 return _wrap_GetTranslation__SWIG_1(self,args);
12030 }
12031 }
12032 }
12033 }
12034
12035 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
12036 return NULL;
12037 }
12038
12039
12040 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12041 PyObject *resultobj;
12042 wxEncodingConverter *result;
12043 char *kwnames[] = {
12044 NULL
12045 };
12046
12047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
12048 {
12049 PyThreadState* __tstate = wxPyBeginAllowThreads();
12050 result = (wxEncodingConverter *)new wxEncodingConverter();
12051
12052 wxPyEndAllowThreads(__tstate);
12053 if (PyErr_Occurred()) SWIG_fail;
12054 }
12055 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
12056 return resultobj;
12057 fail:
12058 return NULL;
12059 }
12060
12061
12062 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12063 PyObject *resultobj;
12064 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12065 PyObject * obj0 = 0 ;
12066 char *kwnames[] = {
12067 (char *) "self", NULL
12068 };
12069
12070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
12071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12072 if (SWIG_arg_fail(1)) SWIG_fail;
12073 {
12074 PyThreadState* __tstate = wxPyBeginAllowThreads();
12075 delete arg1;
12076
12077 wxPyEndAllowThreads(__tstate);
12078 if (PyErr_Occurred()) SWIG_fail;
12079 }
12080 Py_INCREF(Py_None); resultobj = Py_None;
12081 return resultobj;
12082 fail:
12083 return NULL;
12084 }
12085
12086
12087 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
12088 PyObject *resultobj;
12089 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12090 wxFontEncoding arg2 ;
12091 wxFontEncoding arg3 ;
12092 int arg4 = (int) wxCONVERT_STRICT ;
12093 bool result;
12094 PyObject * obj0 = 0 ;
12095 PyObject * obj1 = 0 ;
12096 PyObject * obj2 = 0 ;
12097 PyObject * obj3 = 0 ;
12098 char *kwnames[] = {
12099 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
12100 };
12101
12102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12104 if (SWIG_arg_fail(1)) SWIG_fail;
12105 {
12106 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12107 if (SWIG_arg_fail(2)) SWIG_fail;
12108 }
12109 {
12110 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12111 if (SWIG_arg_fail(3)) SWIG_fail;
12112 }
12113 if (obj3) {
12114 {
12115 arg4 = (int)(SWIG_As_int(obj3));
12116 if (SWIG_arg_fail(4)) SWIG_fail;
12117 }
12118 }
12119 {
12120 PyThreadState* __tstate = wxPyBeginAllowThreads();
12121 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12122
12123 wxPyEndAllowThreads(__tstate);
12124 if (PyErr_Occurred()) SWIG_fail;
12125 }
12126 {
12127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12128 }
12129 return resultobj;
12130 fail:
12131 return NULL;
12132 }
12133
12134
12135 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12136 PyObject *resultobj;
12137 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12138 wxString *arg2 = 0 ;
12139 wxString result;
12140 bool temp2 = false ;
12141 PyObject * obj0 = 0 ;
12142 PyObject * obj1 = 0 ;
12143 char *kwnames[] = {
12144 (char *) "self",(char *) "input", NULL
12145 };
12146
12147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12149 if (SWIG_arg_fail(1)) SWIG_fail;
12150 {
12151 arg2 = wxString_in_helper(obj1);
12152 if (arg2 == NULL) SWIG_fail;
12153 temp2 = true;
12154 }
12155 {
12156 PyThreadState* __tstate = wxPyBeginAllowThreads();
12157 result = (arg1)->Convert((wxString const &)*arg2);
12158
12159 wxPyEndAllowThreads(__tstate);
12160 if (PyErr_Occurred()) SWIG_fail;
12161 }
12162 {
12163 #if wxUSE_UNICODE
12164 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12165 #else
12166 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12167 #endif
12168 }
12169 {
12170 if (temp2)
12171 delete arg2;
12172 }
12173 return resultobj;
12174 fail:
12175 {
12176 if (temp2)
12177 delete arg2;
12178 }
12179 return NULL;
12180 }
12181
12182
12183 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12184 PyObject *resultobj;
12185 wxFontEncoding arg1 ;
12186 int arg2 = (int) wxPLATFORM_CURRENT ;
12187 wxFontEncodingArray result;
12188 PyObject * obj0 = 0 ;
12189 PyObject * obj1 = 0 ;
12190 char *kwnames[] = {
12191 (char *) "enc",(char *) "platform", NULL
12192 };
12193
12194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12195 {
12196 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12197 if (SWIG_arg_fail(1)) SWIG_fail;
12198 }
12199 if (obj1) {
12200 {
12201 arg2 = (int)(SWIG_As_int(obj1));
12202 if (SWIG_arg_fail(2)) SWIG_fail;
12203 }
12204 }
12205 {
12206 PyThreadState* __tstate = wxPyBeginAllowThreads();
12207 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12208
12209 wxPyEndAllowThreads(__tstate);
12210 if (PyErr_Occurred()) SWIG_fail;
12211 }
12212 {
12213 resultobj = PyList_New(0);
12214 for (size_t i=0; i < (&result)->GetCount(); i++) {
12215 PyObject* number = PyInt_FromLong((&result)->Item(i));
12216 PyList_Append(resultobj, number);
12217 Py_DECREF(number);
12218 }
12219 }
12220 return resultobj;
12221 fail:
12222 return NULL;
12223 }
12224
12225
12226 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12227 PyObject *resultobj;
12228 wxFontEncoding arg1 ;
12229 wxFontEncodingArray result;
12230 PyObject * obj0 = 0 ;
12231 char *kwnames[] = {
12232 (char *) "enc", NULL
12233 };
12234
12235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12236 {
12237 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12238 if (SWIG_arg_fail(1)) SWIG_fail;
12239 }
12240 {
12241 PyThreadState* __tstate = wxPyBeginAllowThreads();
12242 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12243
12244 wxPyEndAllowThreads(__tstate);
12245 if (PyErr_Occurred()) SWIG_fail;
12246 }
12247 {
12248 resultobj = PyList_New(0);
12249 for (size_t i=0; i < (&result)->GetCount(); i++) {
12250 PyObject* number = PyInt_FromLong((&result)->Item(i));
12251 PyList_Append(resultobj, number);
12252 Py_DECREF(number);
12253 }
12254 }
12255 return resultobj;
12256 fail:
12257 return NULL;
12258 }
12259
12260
12261 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12262 PyObject *resultobj;
12263 wxFontEncoding arg1 ;
12264 wxFontEncoding arg2 ;
12265 bool result;
12266 PyObject * obj0 = 0 ;
12267 PyObject * obj1 = 0 ;
12268 char *kwnames[] = {
12269 (char *) "encIn",(char *) "encOut", NULL
12270 };
12271
12272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12273 {
12274 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12275 if (SWIG_arg_fail(1)) SWIG_fail;
12276 }
12277 {
12278 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12279 if (SWIG_arg_fail(2)) SWIG_fail;
12280 }
12281 {
12282 PyThreadState* __tstate = wxPyBeginAllowThreads();
12283 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12284
12285 wxPyEndAllowThreads(__tstate);
12286 if (PyErr_Occurred()) SWIG_fail;
12287 }
12288 {
12289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12290 }
12291 return resultobj;
12292 fail:
12293 return NULL;
12294 }
12295
12296
12297 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12298 PyObject *obj;
12299 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12300 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12301 Py_INCREF(obj);
12302 return Py_BuildValue((char *)"");
12303 }
12304 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12305 PyObject *resultobj;
12306 wxDC *arg1 = (wxDC *) 0 ;
12307 PyObject * obj0 = 0 ;
12308 char *kwnames[] = {
12309 (char *) "self", NULL
12310 };
12311
12312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12314 if (SWIG_arg_fail(1)) SWIG_fail;
12315 {
12316 PyThreadState* __tstate = wxPyBeginAllowThreads();
12317 delete arg1;
12318
12319 wxPyEndAllowThreads(__tstate);
12320 if (PyErr_Occurred()) SWIG_fail;
12321 }
12322 Py_INCREF(Py_None); resultobj = Py_None;
12323 return resultobj;
12324 fail:
12325 return NULL;
12326 }
12327
12328
12329 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12330 PyObject *resultobj;
12331 wxDC *arg1 = (wxDC *) 0 ;
12332 PyObject * obj0 = 0 ;
12333 char *kwnames[] = {
12334 (char *) "self", NULL
12335 };
12336
12337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12339 if (SWIG_arg_fail(1)) SWIG_fail;
12340 {
12341 PyThreadState* __tstate = wxPyBeginAllowThreads();
12342 (arg1)->BeginDrawing();
12343
12344 wxPyEndAllowThreads(__tstate);
12345 if (PyErr_Occurred()) SWIG_fail;
12346 }
12347 Py_INCREF(Py_None); resultobj = Py_None;
12348 return resultobj;
12349 fail:
12350 return NULL;
12351 }
12352
12353
12354 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12355 PyObject *resultobj;
12356 wxDC *arg1 = (wxDC *) 0 ;
12357 PyObject * obj0 = 0 ;
12358 char *kwnames[] = {
12359 (char *) "self", NULL
12360 };
12361
12362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12364 if (SWIG_arg_fail(1)) SWIG_fail;
12365 {
12366 PyThreadState* __tstate = wxPyBeginAllowThreads();
12367 (arg1)->EndDrawing();
12368
12369 wxPyEndAllowThreads(__tstate);
12370 if (PyErr_Occurred()) SWIG_fail;
12371 }
12372 Py_INCREF(Py_None); resultobj = Py_None;
12373 return resultobj;
12374 fail:
12375 return NULL;
12376 }
12377
12378
12379 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12380 PyObject *resultobj;
12381 wxDC *arg1 = (wxDC *) 0 ;
12382 int arg2 ;
12383 int arg3 ;
12384 wxColour *arg4 = 0 ;
12385 int arg5 = (int) wxFLOOD_SURFACE ;
12386 bool result;
12387 wxColour temp4 ;
12388 PyObject * obj0 = 0 ;
12389 PyObject * obj1 = 0 ;
12390 PyObject * obj2 = 0 ;
12391 PyObject * obj3 = 0 ;
12392 PyObject * obj4 = 0 ;
12393 char *kwnames[] = {
12394 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12395 };
12396
12397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12399 if (SWIG_arg_fail(1)) SWIG_fail;
12400 {
12401 arg2 = (int)(SWIG_As_int(obj1));
12402 if (SWIG_arg_fail(2)) SWIG_fail;
12403 }
12404 {
12405 arg3 = (int)(SWIG_As_int(obj2));
12406 if (SWIG_arg_fail(3)) SWIG_fail;
12407 }
12408 {
12409 arg4 = &temp4;
12410 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12411 }
12412 if (obj4) {
12413 {
12414 arg5 = (int)(SWIG_As_int(obj4));
12415 if (SWIG_arg_fail(5)) SWIG_fail;
12416 }
12417 }
12418 {
12419 PyThreadState* __tstate = wxPyBeginAllowThreads();
12420 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
12421
12422 wxPyEndAllowThreads(__tstate);
12423 if (PyErr_Occurred()) SWIG_fail;
12424 }
12425 {
12426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12427 }
12428 return resultobj;
12429 fail:
12430 return NULL;
12431 }
12432
12433
12434 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12435 PyObject *resultobj;
12436 wxDC *arg1 = (wxDC *) 0 ;
12437 wxPoint *arg2 = 0 ;
12438 wxColour *arg3 = 0 ;
12439 int arg4 = (int) wxFLOOD_SURFACE ;
12440 bool result;
12441 wxPoint temp2 ;
12442 wxColour temp3 ;
12443 PyObject * obj0 = 0 ;
12444 PyObject * obj1 = 0 ;
12445 PyObject * obj2 = 0 ;
12446 PyObject * obj3 = 0 ;
12447 char *kwnames[] = {
12448 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
12449 };
12450
12451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12453 if (SWIG_arg_fail(1)) SWIG_fail;
12454 {
12455 arg2 = &temp2;
12456 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12457 }
12458 {
12459 arg3 = &temp3;
12460 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
12461 }
12462 if (obj3) {
12463 {
12464 arg4 = (int)(SWIG_As_int(obj3));
12465 if (SWIG_arg_fail(4)) SWIG_fail;
12466 }
12467 }
12468 {
12469 PyThreadState* __tstate = wxPyBeginAllowThreads();
12470 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
12471
12472 wxPyEndAllowThreads(__tstate);
12473 if (PyErr_Occurred()) SWIG_fail;
12474 }
12475 {
12476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12477 }
12478 return resultobj;
12479 fail:
12480 return NULL;
12481 }
12482
12483
12484 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
12485 PyObject *resultobj;
12486 wxDC *arg1 = (wxDC *) 0 ;
12487 int arg2 ;
12488 int arg3 ;
12489 wxColour result;
12490 PyObject * obj0 = 0 ;
12491 PyObject * obj1 = 0 ;
12492 PyObject * obj2 = 0 ;
12493 char *kwnames[] = {
12494 (char *) "self",(char *) "x",(char *) "y", NULL
12495 };
12496
12497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
12498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12499 if (SWIG_arg_fail(1)) SWIG_fail;
12500 {
12501 arg2 = (int)(SWIG_As_int(obj1));
12502 if (SWIG_arg_fail(2)) SWIG_fail;
12503 }
12504 {
12505 arg3 = (int)(SWIG_As_int(obj2));
12506 if (SWIG_arg_fail(3)) SWIG_fail;
12507 }
12508 {
12509 PyThreadState* __tstate = wxPyBeginAllowThreads();
12510 result = wxDC_GetPixel(arg1,arg2,arg3);
12511
12512 wxPyEndAllowThreads(__tstate);
12513 if (PyErr_Occurred()) SWIG_fail;
12514 }
12515 {
12516 wxColour * resultptr;
12517 resultptr = new wxColour((wxColour &)(result));
12518 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12519 }
12520 return resultobj;
12521 fail:
12522 return NULL;
12523 }
12524
12525
12526 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12527 PyObject *resultobj;
12528 wxDC *arg1 = (wxDC *) 0 ;
12529 wxPoint *arg2 = 0 ;
12530 wxColour result;
12531 wxPoint temp2 ;
12532 PyObject * obj0 = 0 ;
12533 PyObject * obj1 = 0 ;
12534 char *kwnames[] = {
12535 (char *) "self",(char *) "pt", NULL
12536 };
12537
12538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
12539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12540 if (SWIG_arg_fail(1)) SWIG_fail;
12541 {
12542 arg2 = &temp2;
12543 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12544 }
12545 {
12546 PyThreadState* __tstate = wxPyBeginAllowThreads();
12547 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
12548
12549 wxPyEndAllowThreads(__tstate);
12550 if (PyErr_Occurred()) SWIG_fail;
12551 }
12552 {
12553 wxColour * resultptr;
12554 resultptr = new wxColour((wxColour &)(result));
12555 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12556 }
12557 return resultobj;
12558 fail:
12559 return NULL;
12560 }
12561
12562
12563 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
12564 PyObject *resultobj;
12565 wxDC *arg1 = (wxDC *) 0 ;
12566 int arg2 ;
12567 int arg3 ;
12568 int arg4 ;
12569 int arg5 ;
12570 PyObject * obj0 = 0 ;
12571 PyObject * obj1 = 0 ;
12572 PyObject * obj2 = 0 ;
12573 PyObject * obj3 = 0 ;
12574 PyObject * obj4 = 0 ;
12575 char *kwnames[] = {
12576 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
12577 };
12578
12579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12581 if (SWIG_arg_fail(1)) SWIG_fail;
12582 {
12583 arg2 = (int)(SWIG_As_int(obj1));
12584 if (SWIG_arg_fail(2)) SWIG_fail;
12585 }
12586 {
12587 arg3 = (int)(SWIG_As_int(obj2));
12588 if (SWIG_arg_fail(3)) SWIG_fail;
12589 }
12590 {
12591 arg4 = (int)(SWIG_As_int(obj3));
12592 if (SWIG_arg_fail(4)) SWIG_fail;
12593 }
12594 {
12595 arg5 = (int)(SWIG_As_int(obj4));
12596 if (SWIG_arg_fail(5)) SWIG_fail;
12597 }
12598 {
12599 PyThreadState* __tstate = wxPyBeginAllowThreads();
12600 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
12601
12602 wxPyEndAllowThreads(__tstate);
12603 if (PyErr_Occurred()) SWIG_fail;
12604 }
12605 Py_INCREF(Py_None); resultobj = Py_None;
12606 return resultobj;
12607 fail:
12608 return NULL;
12609 }
12610
12611
12612 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
12613 PyObject *resultobj;
12614 wxDC *arg1 = (wxDC *) 0 ;
12615 wxPoint *arg2 = 0 ;
12616 wxPoint *arg3 = 0 ;
12617 wxPoint temp2 ;
12618 wxPoint temp3 ;
12619 PyObject * obj0 = 0 ;
12620 PyObject * obj1 = 0 ;
12621 PyObject * obj2 = 0 ;
12622 char *kwnames[] = {
12623 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
12624 };
12625
12626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12628 if (SWIG_arg_fail(1)) SWIG_fail;
12629 {
12630 arg2 = &temp2;
12631 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12632 }
12633 {
12634 arg3 = &temp3;
12635 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12636 }
12637 {
12638 PyThreadState* __tstate = wxPyBeginAllowThreads();
12639 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
12640
12641 wxPyEndAllowThreads(__tstate);
12642 if (PyErr_Occurred()) SWIG_fail;
12643 }
12644 Py_INCREF(Py_None); resultobj = Py_None;
12645 return resultobj;
12646 fail:
12647 return NULL;
12648 }
12649
12650
12651 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
12652 PyObject *resultobj;
12653 wxDC *arg1 = (wxDC *) 0 ;
12654 int arg2 ;
12655 int arg3 ;
12656 PyObject * obj0 = 0 ;
12657 PyObject * obj1 = 0 ;
12658 PyObject * obj2 = 0 ;
12659 char *kwnames[] = {
12660 (char *) "self",(char *) "x",(char *) "y", NULL
12661 };
12662
12663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
12664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12665 if (SWIG_arg_fail(1)) SWIG_fail;
12666 {
12667 arg2 = (int)(SWIG_As_int(obj1));
12668 if (SWIG_arg_fail(2)) SWIG_fail;
12669 }
12670 {
12671 arg3 = (int)(SWIG_As_int(obj2));
12672 if (SWIG_arg_fail(3)) SWIG_fail;
12673 }
12674 {
12675 PyThreadState* __tstate = wxPyBeginAllowThreads();
12676 (arg1)->CrossHair(arg2,arg3);
12677
12678 wxPyEndAllowThreads(__tstate);
12679 if (PyErr_Occurred()) SWIG_fail;
12680 }
12681 Py_INCREF(Py_None); resultobj = Py_None;
12682 return resultobj;
12683 fail:
12684 return NULL;
12685 }
12686
12687
12688 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12689 PyObject *resultobj;
12690 wxDC *arg1 = (wxDC *) 0 ;
12691 wxPoint *arg2 = 0 ;
12692 wxPoint temp2 ;
12693 PyObject * obj0 = 0 ;
12694 PyObject * obj1 = 0 ;
12695 char *kwnames[] = {
12696 (char *) "self",(char *) "pt", NULL
12697 };
12698
12699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
12700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12701 if (SWIG_arg_fail(1)) SWIG_fail;
12702 {
12703 arg2 = &temp2;
12704 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12705 }
12706 {
12707 PyThreadState* __tstate = wxPyBeginAllowThreads();
12708 (arg1)->CrossHair((wxPoint const &)*arg2);
12709
12710 wxPyEndAllowThreads(__tstate);
12711 if (PyErr_Occurred()) SWIG_fail;
12712 }
12713 Py_INCREF(Py_None); resultobj = Py_None;
12714 return resultobj;
12715 fail:
12716 return NULL;
12717 }
12718
12719
12720 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
12721 PyObject *resultobj;
12722 wxDC *arg1 = (wxDC *) 0 ;
12723 int arg2 ;
12724 int arg3 ;
12725 int arg4 ;
12726 int arg5 ;
12727 int arg6 ;
12728 int arg7 ;
12729 PyObject * obj0 = 0 ;
12730 PyObject * obj1 = 0 ;
12731 PyObject * obj2 = 0 ;
12732 PyObject * obj3 = 0 ;
12733 PyObject * obj4 = 0 ;
12734 PyObject * obj5 = 0 ;
12735 PyObject * obj6 = 0 ;
12736 char *kwnames[] = {
12737 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
12738 };
12739
12740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12742 if (SWIG_arg_fail(1)) SWIG_fail;
12743 {
12744 arg2 = (int)(SWIG_As_int(obj1));
12745 if (SWIG_arg_fail(2)) SWIG_fail;
12746 }
12747 {
12748 arg3 = (int)(SWIG_As_int(obj2));
12749 if (SWIG_arg_fail(3)) SWIG_fail;
12750 }
12751 {
12752 arg4 = (int)(SWIG_As_int(obj3));
12753 if (SWIG_arg_fail(4)) SWIG_fail;
12754 }
12755 {
12756 arg5 = (int)(SWIG_As_int(obj4));
12757 if (SWIG_arg_fail(5)) SWIG_fail;
12758 }
12759 {
12760 arg6 = (int)(SWIG_As_int(obj5));
12761 if (SWIG_arg_fail(6)) SWIG_fail;
12762 }
12763 {
12764 arg7 = (int)(SWIG_As_int(obj6));
12765 if (SWIG_arg_fail(7)) SWIG_fail;
12766 }
12767 {
12768 PyThreadState* __tstate = wxPyBeginAllowThreads();
12769 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
12770
12771 wxPyEndAllowThreads(__tstate);
12772 if (PyErr_Occurred()) SWIG_fail;
12773 }
12774 Py_INCREF(Py_None); resultobj = Py_None;
12775 return resultobj;
12776 fail:
12777 return NULL;
12778 }
12779
12780
12781 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12782 PyObject *resultobj;
12783 wxDC *arg1 = (wxDC *) 0 ;
12784 wxPoint *arg2 = 0 ;
12785 wxPoint *arg3 = 0 ;
12786 wxPoint *arg4 = 0 ;
12787 wxPoint temp2 ;
12788 wxPoint temp3 ;
12789 wxPoint temp4 ;
12790 PyObject * obj0 = 0 ;
12791 PyObject * obj1 = 0 ;
12792 PyObject * obj2 = 0 ;
12793 PyObject * obj3 = 0 ;
12794 char *kwnames[] = {
12795 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
12796 };
12797
12798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12800 if (SWIG_arg_fail(1)) SWIG_fail;
12801 {
12802 arg2 = &temp2;
12803 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12804 }
12805 {
12806 arg3 = &temp3;
12807 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12808 }
12809 {
12810 arg4 = &temp4;
12811 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12812 }
12813 {
12814 PyThreadState* __tstate = wxPyBeginAllowThreads();
12815 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
12816
12817 wxPyEndAllowThreads(__tstate);
12818 if (PyErr_Occurred()) SWIG_fail;
12819 }
12820 Py_INCREF(Py_None); resultobj = Py_None;
12821 return resultobj;
12822 fail:
12823 return NULL;
12824 }
12825
12826
12827 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
12828 PyObject *resultobj;
12829 wxDC *arg1 = (wxDC *) 0 ;
12830 int arg2 ;
12831 int arg3 ;
12832 int arg4 ;
12833 int arg5 ;
12834 PyObject * obj0 = 0 ;
12835 PyObject * obj1 = 0 ;
12836 PyObject * obj2 = 0 ;
12837 PyObject * obj3 = 0 ;
12838 PyObject * obj4 = 0 ;
12839 char *kwnames[] = {
12840 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
12841 };
12842
12843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12845 if (SWIG_arg_fail(1)) SWIG_fail;
12846 {
12847 arg2 = (int)(SWIG_As_int(obj1));
12848 if (SWIG_arg_fail(2)) SWIG_fail;
12849 }
12850 {
12851 arg3 = (int)(SWIG_As_int(obj2));
12852 if (SWIG_arg_fail(3)) SWIG_fail;
12853 }
12854 {
12855 arg4 = (int)(SWIG_As_int(obj3));
12856 if (SWIG_arg_fail(4)) SWIG_fail;
12857 }
12858 {
12859 arg5 = (int)(SWIG_As_int(obj4));
12860 if (SWIG_arg_fail(5)) SWIG_fail;
12861 }
12862 {
12863 PyThreadState* __tstate = wxPyBeginAllowThreads();
12864 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
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_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
12877 PyObject *resultobj;
12878 wxDC *arg1 = (wxDC *) 0 ;
12879 wxRect *arg2 = 0 ;
12880 wxRect temp2 ;
12881 PyObject * obj0 = 0 ;
12882 PyObject * obj1 = 0 ;
12883 char *kwnames[] = {
12884 (char *) "self",(char *) "rect", NULL
12885 };
12886
12887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
12888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12889 if (SWIG_arg_fail(1)) SWIG_fail;
12890 {
12891 arg2 = &temp2;
12892 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12893 }
12894 {
12895 PyThreadState* __tstate = wxPyBeginAllowThreads();
12896 (arg1)->DrawCheckMark((wxRect const &)*arg2);
12897
12898 wxPyEndAllowThreads(__tstate);
12899 if (PyErr_Occurred()) SWIG_fail;
12900 }
12901 Py_INCREF(Py_None); resultobj = Py_None;
12902 return resultobj;
12903 fail:
12904 return NULL;
12905 }
12906
12907
12908 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
12909 PyObject *resultobj;
12910 wxDC *arg1 = (wxDC *) 0 ;
12911 int arg2 ;
12912 int arg3 ;
12913 int arg4 ;
12914 int arg5 ;
12915 double arg6 ;
12916 double arg7 ;
12917 PyObject * obj0 = 0 ;
12918 PyObject * obj1 = 0 ;
12919 PyObject * obj2 = 0 ;
12920 PyObject * obj3 = 0 ;
12921 PyObject * obj4 = 0 ;
12922 PyObject * obj5 = 0 ;
12923 PyObject * obj6 = 0 ;
12924 char *kwnames[] = {
12925 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
12926 };
12927
12928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12930 if (SWIG_arg_fail(1)) SWIG_fail;
12931 {
12932 arg2 = (int)(SWIG_As_int(obj1));
12933 if (SWIG_arg_fail(2)) SWIG_fail;
12934 }
12935 {
12936 arg3 = (int)(SWIG_As_int(obj2));
12937 if (SWIG_arg_fail(3)) SWIG_fail;
12938 }
12939 {
12940 arg4 = (int)(SWIG_As_int(obj3));
12941 if (SWIG_arg_fail(4)) SWIG_fail;
12942 }
12943 {
12944 arg5 = (int)(SWIG_As_int(obj4));
12945 if (SWIG_arg_fail(5)) SWIG_fail;
12946 }
12947 {
12948 arg6 = (double)(SWIG_As_double(obj5));
12949 if (SWIG_arg_fail(6)) SWIG_fail;
12950 }
12951 {
12952 arg7 = (double)(SWIG_As_double(obj6));
12953 if (SWIG_arg_fail(7)) SWIG_fail;
12954 }
12955 {
12956 PyThreadState* __tstate = wxPyBeginAllowThreads();
12957 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
12958
12959 wxPyEndAllowThreads(__tstate);
12960 if (PyErr_Occurred()) SWIG_fail;
12961 }
12962 Py_INCREF(Py_None); resultobj = Py_None;
12963 return resultobj;
12964 fail:
12965 return NULL;
12966 }
12967
12968
12969 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
12970 PyObject *resultobj;
12971 wxDC *arg1 = (wxDC *) 0 ;
12972 wxPoint *arg2 = 0 ;
12973 wxSize *arg3 = 0 ;
12974 double arg4 ;
12975 double arg5 ;
12976 wxPoint temp2 ;
12977 wxSize temp3 ;
12978 PyObject * obj0 = 0 ;
12979 PyObject * obj1 = 0 ;
12980 PyObject * obj2 = 0 ;
12981 PyObject * obj3 = 0 ;
12982 PyObject * obj4 = 0 ;
12983 char *kwnames[] = {
12984 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
12985 };
12986
12987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12989 if (SWIG_arg_fail(1)) SWIG_fail;
12990 {
12991 arg2 = &temp2;
12992 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12993 }
12994 {
12995 arg3 = &temp3;
12996 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
12997 }
12998 {
12999 arg4 = (double)(SWIG_As_double(obj3));
13000 if (SWIG_arg_fail(4)) SWIG_fail;
13001 }
13002 {
13003 arg5 = (double)(SWIG_As_double(obj4));
13004 if (SWIG_arg_fail(5)) SWIG_fail;
13005 }
13006 {
13007 PyThreadState* __tstate = wxPyBeginAllowThreads();
13008 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
13009
13010 wxPyEndAllowThreads(__tstate);
13011 if (PyErr_Occurred()) SWIG_fail;
13012 }
13013 Py_INCREF(Py_None); resultobj = Py_None;
13014 return resultobj;
13015 fail:
13016 return NULL;
13017 }
13018
13019
13020 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13021 PyObject *resultobj;
13022 wxDC *arg1 = (wxDC *) 0 ;
13023 int arg2 ;
13024 int arg3 ;
13025 PyObject * obj0 = 0 ;
13026 PyObject * obj1 = 0 ;
13027 PyObject * obj2 = 0 ;
13028 char *kwnames[] = {
13029 (char *) "self",(char *) "x",(char *) "y", NULL
13030 };
13031
13032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13034 if (SWIG_arg_fail(1)) SWIG_fail;
13035 {
13036 arg2 = (int)(SWIG_As_int(obj1));
13037 if (SWIG_arg_fail(2)) SWIG_fail;
13038 }
13039 {
13040 arg3 = (int)(SWIG_As_int(obj2));
13041 if (SWIG_arg_fail(3)) SWIG_fail;
13042 }
13043 {
13044 PyThreadState* __tstate = wxPyBeginAllowThreads();
13045 (arg1)->DrawPoint(arg2,arg3);
13046
13047 wxPyEndAllowThreads(__tstate);
13048 if (PyErr_Occurred()) SWIG_fail;
13049 }
13050 Py_INCREF(Py_None); resultobj = Py_None;
13051 return resultobj;
13052 fail:
13053 return NULL;
13054 }
13055
13056
13057 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13058 PyObject *resultobj;
13059 wxDC *arg1 = (wxDC *) 0 ;
13060 wxPoint *arg2 = 0 ;
13061 wxPoint temp2 ;
13062 PyObject * obj0 = 0 ;
13063 PyObject * obj1 = 0 ;
13064 char *kwnames[] = {
13065 (char *) "self",(char *) "pt", NULL
13066 };
13067
13068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
13069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13070 if (SWIG_arg_fail(1)) SWIG_fail;
13071 {
13072 arg2 = &temp2;
13073 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13074 }
13075 {
13076 PyThreadState* __tstate = wxPyBeginAllowThreads();
13077 (arg1)->DrawPoint((wxPoint const &)*arg2);
13078
13079 wxPyEndAllowThreads(__tstate);
13080 if (PyErr_Occurred()) SWIG_fail;
13081 }
13082 Py_INCREF(Py_None); resultobj = Py_None;
13083 return resultobj;
13084 fail:
13085 return NULL;
13086 }
13087
13088
13089 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13090 PyObject *resultobj;
13091 wxDC *arg1 = (wxDC *) 0 ;
13092 int arg2 ;
13093 int arg3 ;
13094 int arg4 ;
13095 int arg5 ;
13096 PyObject * obj0 = 0 ;
13097 PyObject * obj1 = 0 ;
13098 PyObject * obj2 = 0 ;
13099 PyObject * obj3 = 0 ;
13100 PyObject * obj4 = 0 ;
13101 char *kwnames[] = {
13102 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13103 };
13104
13105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13107 if (SWIG_arg_fail(1)) SWIG_fail;
13108 {
13109 arg2 = (int)(SWIG_As_int(obj1));
13110 if (SWIG_arg_fail(2)) SWIG_fail;
13111 }
13112 {
13113 arg3 = (int)(SWIG_As_int(obj2));
13114 if (SWIG_arg_fail(3)) SWIG_fail;
13115 }
13116 {
13117 arg4 = (int)(SWIG_As_int(obj3));
13118 if (SWIG_arg_fail(4)) SWIG_fail;
13119 }
13120 {
13121 arg5 = (int)(SWIG_As_int(obj4));
13122 if (SWIG_arg_fail(5)) SWIG_fail;
13123 }
13124 {
13125 PyThreadState* __tstate = wxPyBeginAllowThreads();
13126 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13127
13128 wxPyEndAllowThreads(__tstate);
13129 if (PyErr_Occurred()) SWIG_fail;
13130 }
13131 Py_INCREF(Py_None); resultobj = Py_None;
13132 return resultobj;
13133 fail:
13134 return NULL;
13135 }
13136
13137
13138 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13139 PyObject *resultobj;
13140 wxDC *arg1 = (wxDC *) 0 ;
13141 wxRect *arg2 = 0 ;
13142 wxRect temp2 ;
13143 PyObject * obj0 = 0 ;
13144 PyObject * obj1 = 0 ;
13145 char *kwnames[] = {
13146 (char *) "self",(char *) "rect", NULL
13147 };
13148
13149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13151 if (SWIG_arg_fail(1)) SWIG_fail;
13152 {
13153 arg2 = &temp2;
13154 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13155 }
13156 {
13157 PyThreadState* __tstate = wxPyBeginAllowThreads();
13158 (arg1)->DrawRectangle((wxRect const &)*arg2);
13159
13160 wxPyEndAllowThreads(__tstate);
13161 if (PyErr_Occurred()) SWIG_fail;
13162 }
13163 Py_INCREF(Py_None); resultobj = Py_None;
13164 return resultobj;
13165 fail:
13166 return NULL;
13167 }
13168
13169
13170 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13171 PyObject *resultobj;
13172 wxDC *arg1 = (wxDC *) 0 ;
13173 wxPoint *arg2 = 0 ;
13174 wxSize *arg3 = 0 ;
13175 wxPoint temp2 ;
13176 wxSize temp3 ;
13177 PyObject * obj0 = 0 ;
13178 PyObject * obj1 = 0 ;
13179 PyObject * obj2 = 0 ;
13180 char *kwnames[] = {
13181 (char *) "self",(char *) "pt",(char *) "sz", NULL
13182 };
13183
13184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13186 if (SWIG_arg_fail(1)) SWIG_fail;
13187 {
13188 arg2 = &temp2;
13189 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13190 }
13191 {
13192 arg3 = &temp3;
13193 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13194 }
13195 {
13196 PyThreadState* __tstate = wxPyBeginAllowThreads();
13197 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13198
13199 wxPyEndAllowThreads(__tstate);
13200 if (PyErr_Occurred()) SWIG_fail;
13201 }
13202 Py_INCREF(Py_None); resultobj = Py_None;
13203 return resultobj;
13204 fail:
13205 return NULL;
13206 }
13207
13208
13209 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13210 PyObject *resultobj;
13211 wxDC *arg1 = (wxDC *) 0 ;
13212 int arg2 ;
13213 int arg3 ;
13214 int arg4 ;
13215 int arg5 ;
13216 double arg6 ;
13217 PyObject * obj0 = 0 ;
13218 PyObject * obj1 = 0 ;
13219 PyObject * obj2 = 0 ;
13220 PyObject * obj3 = 0 ;
13221 PyObject * obj4 = 0 ;
13222 PyObject * obj5 = 0 ;
13223 char *kwnames[] = {
13224 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13225 };
13226
13227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13229 if (SWIG_arg_fail(1)) SWIG_fail;
13230 {
13231 arg2 = (int)(SWIG_As_int(obj1));
13232 if (SWIG_arg_fail(2)) SWIG_fail;
13233 }
13234 {
13235 arg3 = (int)(SWIG_As_int(obj2));
13236 if (SWIG_arg_fail(3)) SWIG_fail;
13237 }
13238 {
13239 arg4 = (int)(SWIG_As_int(obj3));
13240 if (SWIG_arg_fail(4)) SWIG_fail;
13241 }
13242 {
13243 arg5 = (int)(SWIG_As_int(obj4));
13244 if (SWIG_arg_fail(5)) SWIG_fail;
13245 }
13246 {
13247 arg6 = (double)(SWIG_As_double(obj5));
13248 if (SWIG_arg_fail(6)) SWIG_fail;
13249 }
13250 {
13251 PyThreadState* __tstate = wxPyBeginAllowThreads();
13252 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13253
13254 wxPyEndAllowThreads(__tstate);
13255 if (PyErr_Occurred()) SWIG_fail;
13256 }
13257 Py_INCREF(Py_None); resultobj = Py_None;
13258 return resultobj;
13259 fail:
13260 return NULL;
13261 }
13262
13263
13264 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13265 PyObject *resultobj;
13266 wxDC *arg1 = (wxDC *) 0 ;
13267 wxRect *arg2 = 0 ;
13268 double arg3 ;
13269 wxRect temp2 ;
13270 PyObject * obj0 = 0 ;
13271 PyObject * obj1 = 0 ;
13272 PyObject * obj2 = 0 ;
13273 char *kwnames[] = {
13274 (char *) "self",(char *) "r",(char *) "radius", NULL
13275 };
13276
13277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13279 if (SWIG_arg_fail(1)) SWIG_fail;
13280 {
13281 arg2 = &temp2;
13282 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13283 }
13284 {
13285 arg3 = (double)(SWIG_As_double(obj2));
13286 if (SWIG_arg_fail(3)) SWIG_fail;
13287 }
13288 {
13289 PyThreadState* __tstate = wxPyBeginAllowThreads();
13290 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13291
13292 wxPyEndAllowThreads(__tstate);
13293 if (PyErr_Occurred()) SWIG_fail;
13294 }
13295 Py_INCREF(Py_None); resultobj = Py_None;
13296 return resultobj;
13297 fail:
13298 return NULL;
13299 }
13300
13301
13302 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13303 PyObject *resultobj;
13304 wxDC *arg1 = (wxDC *) 0 ;
13305 wxPoint *arg2 = 0 ;
13306 wxSize *arg3 = 0 ;
13307 double arg4 ;
13308 wxPoint temp2 ;
13309 wxSize temp3 ;
13310 PyObject * obj0 = 0 ;
13311 PyObject * obj1 = 0 ;
13312 PyObject * obj2 = 0 ;
13313 PyObject * obj3 = 0 ;
13314 char *kwnames[] = {
13315 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13316 };
13317
13318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13320 if (SWIG_arg_fail(1)) SWIG_fail;
13321 {
13322 arg2 = &temp2;
13323 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13324 }
13325 {
13326 arg3 = &temp3;
13327 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13328 }
13329 {
13330 arg4 = (double)(SWIG_As_double(obj3));
13331 if (SWIG_arg_fail(4)) SWIG_fail;
13332 }
13333 {
13334 PyThreadState* __tstate = wxPyBeginAllowThreads();
13335 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13336
13337 wxPyEndAllowThreads(__tstate);
13338 if (PyErr_Occurred()) SWIG_fail;
13339 }
13340 Py_INCREF(Py_None); resultobj = Py_None;
13341 return resultobj;
13342 fail:
13343 return NULL;
13344 }
13345
13346
13347 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13348 PyObject *resultobj;
13349 wxDC *arg1 = (wxDC *) 0 ;
13350 int arg2 ;
13351 int arg3 ;
13352 int arg4 ;
13353 PyObject * obj0 = 0 ;
13354 PyObject * obj1 = 0 ;
13355 PyObject * obj2 = 0 ;
13356 PyObject * obj3 = 0 ;
13357 char *kwnames[] = {
13358 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13359 };
13360
13361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13363 if (SWIG_arg_fail(1)) SWIG_fail;
13364 {
13365 arg2 = (int)(SWIG_As_int(obj1));
13366 if (SWIG_arg_fail(2)) SWIG_fail;
13367 }
13368 {
13369 arg3 = (int)(SWIG_As_int(obj2));
13370 if (SWIG_arg_fail(3)) SWIG_fail;
13371 }
13372 {
13373 arg4 = (int)(SWIG_As_int(obj3));
13374 if (SWIG_arg_fail(4)) SWIG_fail;
13375 }
13376 {
13377 PyThreadState* __tstate = wxPyBeginAllowThreads();
13378 (arg1)->DrawCircle(arg2,arg3,arg4);
13379
13380 wxPyEndAllowThreads(__tstate);
13381 if (PyErr_Occurred()) SWIG_fail;
13382 }
13383 Py_INCREF(Py_None); resultobj = Py_None;
13384 return resultobj;
13385 fail:
13386 return NULL;
13387 }
13388
13389
13390 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13391 PyObject *resultobj;
13392 wxDC *arg1 = (wxDC *) 0 ;
13393 wxPoint *arg2 = 0 ;
13394 int arg3 ;
13395 wxPoint temp2 ;
13396 PyObject * obj0 = 0 ;
13397 PyObject * obj1 = 0 ;
13398 PyObject * obj2 = 0 ;
13399 char *kwnames[] = {
13400 (char *) "self",(char *) "pt",(char *) "radius", NULL
13401 };
13402
13403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13405 if (SWIG_arg_fail(1)) SWIG_fail;
13406 {
13407 arg2 = &temp2;
13408 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13409 }
13410 {
13411 arg3 = (int)(SWIG_As_int(obj2));
13412 if (SWIG_arg_fail(3)) SWIG_fail;
13413 }
13414 {
13415 PyThreadState* __tstate = wxPyBeginAllowThreads();
13416 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13417
13418 wxPyEndAllowThreads(__tstate);
13419 if (PyErr_Occurred()) SWIG_fail;
13420 }
13421 Py_INCREF(Py_None); resultobj = Py_None;
13422 return resultobj;
13423 fail:
13424 return NULL;
13425 }
13426
13427
13428 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
13429 PyObject *resultobj;
13430 wxDC *arg1 = (wxDC *) 0 ;
13431 int arg2 ;
13432 int arg3 ;
13433 int arg4 ;
13434 int arg5 ;
13435 PyObject * obj0 = 0 ;
13436 PyObject * obj1 = 0 ;
13437 PyObject * obj2 = 0 ;
13438 PyObject * obj3 = 0 ;
13439 PyObject * obj4 = 0 ;
13440 char *kwnames[] = {
13441 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13442 };
13443
13444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13446 if (SWIG_arg_fail(1)) SWIG_fail;
13447 {
13448 arg2 = (int)(SWIG_As_int(obj1));
13449 if (SWIG_arg_fail(2)) SWIG_fail;
13450 }
13451 {
13452 arg3 = (int)(SWIG_As_int(obj2));
13453 if (SWIG_arg_fail(3)) SWIG_fail;
13454 }
13455 {
13456 arg4 = (int)(SWIG_As_int(obj3));
13457 if (SWIG_arg_fail(4)) SWIG_fail;
13458 }
13459 {
13460 arg5 = (int)(SWIG_As_int(obj4));
13461 if (SWIG_arg_fail(5)) SWIG_fail;
13462 }
13463 {
13464 PyThreadState* __tstate = wxPyBeginAllowThreads();
13465 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
13466
13467 wxPyEndAllowThreads(__tstate);
13468 if (PyErr_Occurred()) SWIG_fail;
13469 }
13470 Py_INCREF(Py_None); resultobj = Py_None;
13471 return resultobj;
13472 fail:
13473 return NULL;
13474 }
13475
13476
13477 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
13478 PyObject *resultobj;
13479 wxDC *arg1 = (wxDC *) 0 ;
13480 wxRect *arg2 = 0 ;
13481 wxRect temp2 ;
13482 PyObject * obj0 = 0 ;
13483 PyObject * obj1 = 0 ;
13484 char *kwnames[] = {
13485 (char *) "self",(char *) "rect", NULL
13486 };
13487
13488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
13489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13490 if (SWIG_arg_fail(1)) SWIG_fail;
13491 {
13492 arg2 = &temp2;
13493 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13494 }
13495 {
13496 PyThreadState* __tstate = wxPyBeginAllowThreads();
13497 (arg1)->DrawEllipse((wxRect const &)*arg2);
13498
13499 wxPyEndAllowThreads(__tstate);
13500 if (PyErr_Occurred()) SWIG_fail;
13501 }
13502 Py_INCREF(Py_None); resultobj = Py_None;
13503 return resultobj;
13504 fail:
13505 return NULL;
13506 }
13507
13508
13509 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13510 PyObject *resultobj;
13511 wxDC *arg1 = (wxDC *) 0 ;
13512 wxPoint *arg2 = 0 ;
13513 wxSize *arg3 = 0 ;
13514 wxPoint temp2 ;
13515 wxSize temp3 ;
13516 PyObject * obj0 = 0 ;
13517 PyObject * obj1 = 0 ;
13518 PyObject * obj2 = 0 ;
13519 char *kwnames[] = {
13520 (char *) "self",(char *) "pt",(char *) "sz", NULL
13521 };
13522
13523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13525 if (SWIG_arg_fail(1)) SWIG_fail;
13526 {
13527 arg2 = &temp2;
13528 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13529 }
13530 {
13531 arg3 = &temp3;
13532 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13533 }
13534 {
13535 PyThreadState* __tstate = wxPyBeginAllowThreads();
13536 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
13537
13538 wxPyEndAllowThreads(__tstate);
13539 if (PyErr_Occurred()) SWIG_fail;
13540 }
13541 Py_INCREF(Py_None); resultobj = Py_None;
13542 return resultobj;
13543 fail:
13544 return NULL;
13545 }
13546
13547
13548 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13549 PyObject *resultobj;
13550 wxDC *arg1 = (wxDC *) 0 ;
13551 wxIcon *arg2 = 0 ;
13552 int arg3 ;
13553 int arg4 ;
13554 PyObject * obj0 = 0 ;
13555 PyObject * obj1 = 0 ;
13556 PyObject * obj2 = 0 ;
13557 PyObject * obj3 = 0 ;
13558 char *kwnames[] = {
13559 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
13560 };
13561
13562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13564 if (SWIG_arg_fail(1)) SWIG_fail;
13565 {
13566 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13567 if (SWIG_arg_fail(2)) SWIG_fail;
13568 if (arg2 == NULL) {
13569 SWIG_null_ref("wxIcon");
13570 }
13571 if (SWIG_arg_fail(2)) SWIG_fail;
13572 }
13573 {
13574 arg3 = (int)(SWIG_As_int(obj2));
13575 if (SWIG_arg_fail(3)) SWIG_fail;
13576 }
13577 {
13578 arg4 = (int)(SWIG_As_int(obj3));
13579 if (SWIG_arg_fail(4)) SWIG_fail;
13580 }
13581 {
13582 PyThreadState* __tstate = wxPyBeginAllowThreads();
13583 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
13584
13585 wxPyEndAllowThreads(__tstate);
13586 if (PyErr_Occurred()) SWIG_fail;
13587 }
13588 Py_INCREF(Py_None); resultobj = Py_None;
13589 return resultobj;
13590 fail:
13591 return NULL;
13592 }
13593
13594
13595 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13596 PyObject *resultobj;
13597 wxDC *arg1 = (wxDC *) 0 ;
13598 wxIcon *arg2 = 0 ;
13599 wxPoint *arg3 = 0 ;
13600 wxPoint temp3 ;
13601 PyObject * obj0 = 0 ;
13602 PyObject * obj1 = 0 ;
13603 PyObject * obj2 = 0 ;
13604 char *kwnames[] = {
13605 (char *) "self",(char *) "icon",(char *) "pt", NULL
13606 };
13607
13608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13610 if (SWIG_arg_fail(1)) SWIG_fail;
13611 {
13612 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13613 if (SWIG_arg_fail(2)) SWIG_fail;
13614 if (arg2 == NULL) {
13615 SWIG_null_ref("wxIcon");
13616 }
13617 if (SWIG_arg_fail(2)) SWIG_fail;
13618 }
13619 {
13620 arg3 = &temp3;
13621 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13622 }
13623 {
13624 PyThreadState* __tstate = wxPyBeginAllowThreads();
13625 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
13626
13627 wxPyEndAllowThreads(__tstate);
13628 if (PyErr_Occurred()) SWIG_fail;
13629 }
13630 Py_INCREF(Py_None); resultobj = Py_None;
13631 return resultobj;
13632 fail:
13633 return NULL;
13634 }
13635
13636
13637 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13638 PyObject *resultobj;
13639 wxDC *arg1 = (wxDC *) 0 ;
13640 wxBitmap *arg2 = 0 ;
13641 int arg3 ;
13642 int arg4 ;
13643 bool arg5 = (bool) false ;
13644 PyObject * obj0 = 0 ;
13645 PyObject * obj1 = 0 ;
13646 PyObject * obj2 = 0 ;
13647 PyObject * obj3 = 0 ;
13648 PyObject * obj4 = 0 ;
13649 char *kwnames[] = {
13650 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
13651 };
13652
13653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13655 if (SWIG_arg_fail(1)) SWIG_fail;
13656 {
13657 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13658 if (SWIG_arg_fail(2)) SWIG_fail;
13659 if (arg2 == NULL) {
13660 SWIG_null_ref("wxBitmap");
13661 }
13662 if (SWIG_arg_fail(2)) SWIG_fail;
13663 }
13664 {
13665 arg3 = (int)(SWIG_As_int(obj2));
13666 if (SWIG_arg_fail(3)) SWIG_fail;
13667 }
13668 {
13669 arg4 = (int)(SWIG_As_int(obj3));
13670 if (SWIG_arg_fail(4)) SWIG_fail;
13671 }
13672 if (obj4) {
13673 {
13674 arg5 = (bool)(SWIG_As_bool(obj4));
13675 if (SWIG_arg_fail(5)) SWIG_fail;
13676 }
13677 }
13678 {
13679 PyThreadState* __tstate = wxPyBeginAllowThreads();
13680 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
13681
13682 wxPyEndAllowThreads(__tstate);
13683 if (PyErr_Occurred()) SWIG_fail;
13684 }
13685 Py_INCREF(Py_None); resultobj = Py_None;
13686 return resultobj;
13687 fail:
13688 return NULL;
13689 }
13690
13691
13692 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13693 PyObject *resultobj;
13694 wxDC *arg1 = (wxDC *) 0 ;
13695 wxBitmap *arg2 = 0 ;
13696 wxPoint *arg3 = 0 ;
13697 bool arg4 = (bool) false ;
13698 wxPoint temp3 ;
13699 PyObject * obj0 = 0 ;
13700 PyObject * obj1 = 0 ;
13701 PyObject * obj2 = 0 ;
13702 PyObject * obj3 = 0 ;
13703 char *kwnames[] = {
13704 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
13705 };
13706
13707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13709 if (SWIG_arg_fail(1)) SWIG_fail;
13710 {
13711 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13712 if (SWIG_arg_fail(2)) SWIG_fail;
13713 if (arg2 == NULL) {
13714 SWIG_null_ref("wxBitmap");
13715 }
13716 if (SWIG_arg_fail(2)) SWIG_fail;
13717 }
13718 {
13719 arg3 = &temp3;
13720 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13721 }
13722 if (obj3) {
13723 {
13724 arg4 = (bool)(SWIG_As_bool(obj3));
13725 if (SWIG_arg_fail(4)) SWIG_fail;
13726 }
13727 }
13728 {
13729 PyThreadState* __tstate = wxPyBeginAllowThreads();
13730 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
13731
13732 wxPyEndAllowThreads(__tstate);
13733 if (PyErr_Occurred()) SWIG_fail;
13734 }
13735 Py_INCREF(Py_None); resultobj = Py_None;
13736 return resultobj;
13737 fail:
13738 return NULL;
13739 }
13740
13741
13742 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
13743 PyObject *resultobj;
13744 wxDC *arg1 = (wxDC *) 0 ;
13745 wxString *arg2 = 0 ;
13746 int arg3 ;
13747 int arg4 ;
13748 bool temp2 = false ;
13749 PyObject * obj0 = 0 ;
13750 PyObject * obj1 = 0 ;
13751 PyObject * obj2 = 0 ;
13752 PyObject * obj3 = 0 ;
13753 char *kwnames[] = {
13754 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
13755 };
13756
13757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13759 if (SWIG_arg_fail(1)) SWIG_fail;
13760 {
13761 arg2 = wxString_in_helper(obj1);
13762 if (arg2 == NULL) SWIG_fail;
13763 temp2 = true;
13764 }
13765 {
13766 arg3 = (int)(SWIG_As_int(obj2));
13767 if (SWIG_arg_fail(3)) SWIG_fail;
13768 }
13769 {
13770 arg4 = (int)(SWIG_As_int(obj3));
13771 if (SWIG_arg_fail(4)) SWIG_fail;
13772 }
13773 {
13774 PyThreadState* __tstate = wxPyBeginAllowThreads();
13775 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
13776
13777 wxPyEndAllowThreads(__tstate);
13778 if (PyErr_Occurred()) SWIG_fail;
13779 }
13780 Py_INCREF(Py_None); resultobj = Py_None;
13781 {
13782 if (temp2)
13783 delete arg2;
13784 }
13785 return resultobj;
13786 fail:
13787 {
13788 if (temp2)
13789 delete arg2;
13790 }
13791 return NULL;
13792 }
13793
13794
13795 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13796 PyObject *resultobj;
13797 wxDC *arg1 = (wxDC *) 0 ;
13798 wxString *arg2 = 0 ;
13799 wxPoint *arg3 = 0 ;
13800 bool temp2 = false ;
13801 wxPoint temp3 ;
13802 PyObject * obj0 = 0 ;
13803 PyObject * obj1 = 0 ;
13804 PyObject * obj2 = 0 ;
13805 char *kwnames[] = {
13806 (char *) "self",(char *) "text",(char *) "pt", NULL
13807 };
13808
13809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13811 if (SWIG_arg_fail(1)) SWIG_fail;
13812 {
13813 arg2 = wxString_in_helper(obj1);
13814 if (arg2 == NULL) SWIG_fail;
13815 temp2 = true;
13816 }
13817 {
13818 arg3 = &temp3;
13819 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13820 }
13821 {
13822 PyThreadState* __tstate = wxPyBeginAllowThreads();
13823 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
13824
13825 wxPyEndAllowThreads(__tstate);
13826 if (PyErr_Occurred()) SWIG_fail;
13827 }
13828 Py_INCREF(Py_None); resultobj = Py_None;
13829 {
13830 if (temp2)
13831 delete arg2;
13832 }
13833 return resultobj;
13834 fail:
13835 {
13836 if (temp2)
13837 delete arg2;
13838 }
13839 return NULL;
13840 }
13841
13842
13843 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
13844 PyObject *resultobj;
13845 wxDC *arg1 = (wxDC *) 0 ;
13846 wxString *arg2 = 0 ;
13847 int arg3 ;
13848 int arg4 ;
13849 double arg5 ;
13850 bool temp2 = false ;
13851 PyObject * obj0 = 0 ;
13852 PyObject * obj1 = 0 ;
13853 PyObject * obj2 = 0 ;
13854 PyObject * obj3 = 0 ;
13855 PyObject * obj4 = 0 ;
13856 char *kwnames[] = {
13857 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
13858 };
13859
13860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13862 if (SWIG_arg_fail(1)) SWIG_fail;
13863 {
13864 arg2 = wxString_in_helper(obj1);
13865 if (arg2 == NULL) SWIG_fail;
13866 temp2 = true;
13867 }
13868 {
13869 arg3 = (int)(SWIG_As_int(obj2));
13870 if (SWIG_arg_fail(3)) SWIG_fail;
13871 }
13872 {
13873 arg4 = (int)(SWIG_As_int(obj3));
13874 if (SWIG_arg_fail(4)) SWIG_fail;
13875 }
13876 {
13877 arg5 = (double)(SWIG_As_double(obj4));
13878 if (SWIG_arg_fail(5)) SWIG_fail;
13879 }
13880 {
13881 PyThreadState* __tstate = wxPyBeginAllowThreads();
13882 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
13883
13884 wxPyEndAllowThreads(__tstate);
13885 if (PyErr_Occurred()) SWIG_fail;
13886 }
13887 Py_INCREF(Py_None); resultobj = Py_None;
13888 {
13889 if (temp2)
13890 delete arg2;
13891 }
13892 return resultobj;
13893 fail:
13894 {
13895 if (temp2)
13896 delete arg2;
13897 }
13898 return NULL;
13899 }
13900
13901
13902 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13903 PyObject *resultobj;
13904 wxDC *arg1 = (wxDC *) 0 ;
13905 wxString *arg2 = 0 ;
13906 wxPoint *arg3 = 0 ;
13907 double arg4 ;
13908 bool temp2 = false ;
13909 wxPoint temp3 ;
13910 PyObject * obj0 = 0 ;
13911 PyObject * obj1 = 0 ;
13912 PyObject * obj2 = 0 ;
13913 PyObject * obj3 = 0 ;
13914 char *kwnames[] = {
13915 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
13916 };
13917
13918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13920 if (SWIG_arg_fail(1)) SWIG_fail;
13921 {
13922 arg2 = wxString_in_helper(obj1);
13923 if (arg2 == NULL) SWIG_fail;
13924 temp2 = true;
13925 }
13926 {
13927 arg3 = &temp3;
13928 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13929 }
13930 {
13931 arg4 = (double)(SWIG_As_double(obj3));
13932 if (SWIG_arg_fail(4)) SWIG_fail;
13933 }
13934 {
13935 PyThreadState* __tstate = wxPyBeginAllowThreads();
13936 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
13937
13938 wxPyEndAllowThreads(__tstate);
13939 if (PyErr_Occurred()) SWIG_fail;
13940 }
13941 Py_INCREF(Py_None); resultobj = Py_None;
13942 {
13943 if (temp2)
13944 delete arg2;
13945 }
13946 return resultobj;
13947 fail:
13948 {
13949 if (temp2)
13950 delete arg2;
13951 }
13952 return NULL;
13953 }
13954
13955
13956 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
13957 PyObject *resultobj;
13958 wxDC *arg1 = (wxDC *) 0 ;
13959 int arg2 ;
13960 int arg3 ;
13961 int arg4 ;
13962 int arg5 ;
13963 wxDC *arg6 = (wxDC *) 0 ;
13964 int arg7 ;
13965 int arg8 ;
13966 int arg9 = (int) wxCOPY ;
13967 bool arg10 = (bool) false ;
13968 int arg11 = (int) -1 ;
13969 int arg12 = (int) -1 ;
13970 bool result;
13971 PyObject * obj0 = 0 ;
13972 PyObject * obj1 = 0 ;
13973 PyObject * obj2 = 0 ;
13974 PyObject * obj3 = 0 ;
13975 PyObject * obj4 = 0 ;
13976 PyObject * obj5 = 0 ;
13977 PyObject * obj6 = 0 ;
13978 PyObject * obj7 = 0 ;
13979 PyObject * obj8 = 0 ;
13980 PyObject * obj9 = 0 ;
13981 PyObject * obj10 = 0 ;
13982 PyObject * obj11 = 0 ;
13983 char *kwnames[] = {
13984 (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
13985 };
13986
13987 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;
13988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13989 if (SWIG_arg_fail(1)) SWIG_fail;
13990 {
13991 arg2 = (int)(SWIG_As_int(obj1));
13992 if (SWIG_arg_fail(2)) SWIG_fail;
13993 }
13994 {
13995 arg3 = (int)(SWIG_As_int(obj2));
13996 if (SWIG_arg_fail(3)) SWIG_fail;
13997 }
13998 {
13999 arg4 = (int)(SWIG_As_int(obj3));
14000 if (SWIG_arg_fail(4)) SWIG_fail;
14001 }
14002 {
14003 arg5 = (int)(SWIG_As_int(obj4));
14004 if (SWIG_arg_fail(5)) SWIG_fail;
14005 }
14006 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14007 if (SWIG_arg_fail(6)) SWIG_fail;
14008 {
14009 arg7 = (int)(SWIG_As_int(obj6));
14010 if (SWIG_arg_fail(7)) SWIG_fail;
14011 }
14012 {
14013 arg8 = (int)(SWIG_As_int(obj7));
14014 if (SWIG_arg_fail(8)) SWIG_fail;
14015 }
14016 if (obj8) {
14017 {
14018 arg9 = (int)(SWIG_As_int(obj8));
14019 if (SWIG_arg_fail(9)) SWIG_fail;
14020 }
14021 }
14022 if (obj9) {
14023 {
14024 arg10 = (bool)(SWIG_As_bool(obj9));
14025 if (SWIG_arg_fail(10)) SWIG_fail;
14026 }
14027 }
14028 if (obj10) {
14029 {
14030 arg11 = (int)(SWIG_As_int(obj10));
14031 if (SWIG_arg_fail(11)) SWIG_fail;
14032 }
14033 }
14034 if (obj11) {
14035 {
14036 arg12 = (int)(SWIG_As_int(obj11));
14037 if (SWIG_arg_fail(12)) SWIG_fail;
14038 }
14039 }
14040 {
14041 PyThreadState* __tstate = wxPyBeginAllowThreads();
14042 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14043
14044 wxPyEndAllowThreads(__tstate);
14045 if (PyErr_Occurred()) SWIG_fail;
14046 }
14047 {
14048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14049 }
14050 return resultobj;
14051 fail:
14052 return NULL;
14053 }
14054
14055
14056 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14057 PyObject *resultobj;
14058 wxDC *arg1 = (wxDC *) 0 ;
14059 wxPoint *arg2 = 0 ;
14060 wxSize *arg3 = 0 ;
14061 wxDC *arg4 = (wxDC *) 0 ;
14062 wxPoint *arg5 = 0 ;
14063 int arg6 = (int) wxCOPY ;
14064 bool arg7 = (bool) false ;
14065 wxPoint const &arg8_defvalue = wxDefaultPosition ;
14066 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
14067 bool result;
14068 wxPoint temp2 ;
14069 wxSize temp3 ;
14070 wxPoint temp5 ;
14071 wxPoint temp8 ;
14072 PyObject * obj0 = 0 ;
14073 PyObject * obj1 = 0 ;
14074 PyObject * obj2 = 0 ;
14075 PyObject * obj3 = 0 ;
14076 PyObject * obj4 = 0 ;
14077 PyObject * obj5 = 0 ;
14078 PyObject * obj6 = 0 ;
14079 PyObject * obj7 = 0 ;
14080 char *kwnames[] = {
14081 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
14082 };
14083
14084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
14085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14086 if (SWIG_arg_fail(1)) SWIG_fail;
14087 {
14088 arg2 = &temp2;
14089 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14090 }
14091 {
14092 arg3 = &temp3;
14093 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14094 }
14095 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14096 if (SWIG_arg_fail(4)) SWIG_fail;
14097 {
14098 arg5 = &temp5;
14099 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14100 }
14101 if (obj5) {
14102 {
14103 arg6 = (int)(SWIG_As_int(obj5));
14104 if (SWIG_arg_fail(6)) SWIG_fail;
14105 }
14106 }
14107 if (obj6) {
14108 {
14109 arg7 = (bool)(SWIG_As_bool(obj6));
14110 if (SWIG_arg_fail(7)) SWIG_fail;
14111 }
14112 }
14113 if (obj7) {
14114 {
14115 arg8 = &temp8;
14116 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14117 }
14118 }
14119 {
14120 PyThreadState* __tstate = wxPyBeginAllowThreads();
14121 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14122
14123 wxPyEndAllowThreads(__tstate);
14124 if (PyErr_Occurred()) SWIG_fail;
14125 }
14126 {
14127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14128 }
14129 return resultobj;
14130 fail:
14131 return NULL;
14132 }
14133
14134
14135 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14136 PyObject *resultobj;
14137 wxDC *arg1 = (wxDC *) 0 ;
14138 int arg2 ;
14139 int arg3 ;
14140 int arg4 ;
14141 int arg5 ;
14142 PyObject * obj0 = 0 ;
14143 PyObject * obj1 = 0 ;
14144 PyObject * obj2 = 0 ;
14145 PyObject * obj3 = 0 ;
14146 PyObject * obj4 = 0 ;
14147 char *kwnames[] = {
14148 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14149 };
14150
14151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14153 if (SWIG_arg_fail(1)) SWIG_fail;
14154 {
14155 arg2 = (int)(SWIG_As_int(obj1));
14156 if (SWIG_arg_fail(2)) SWIG_fail;
14157 }
14158 {
14159 arg3 = (int)(SWIG_As_int(obj2));
14160 if (SWIG_arg_fail(3)) SWIG_fail;
14161 }
14162 {
14163 arg4 = (int)(SWIG_As_int(obj3));
14164 if (SWIG_arg_fail(4)) SWIG_fail;
14165 }
14166 {
14167 arg5 = (int)(SWIG_As_int(obj4));
14168 if (SWIG_arg_fail(5)) SWIG_fail;
14169 }
14170 {
14171 PyThreadState* __tstate = wxPyBeginAllowThreads();
14172 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
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_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14185 PyObject *resultobj;
14186 wxDC *arg1 = (wxDC *) 0 ;
14187 wxPoint *arg2 = 0 ;
14188 wxSize *arg3 = 0 ;
14189 wxPoint temp2 ;
14190 wxSize temp3 ;
14191 PyObject * obj0 = 0 ;
14192 PyObject * obj1 = 0 ;
14193 PyObject * obj2 = 0 ;
14194 char *kwnames[] = {
14195 (char *) "self",(char *) "pt",(char *) "sz", NULL
14196 };
14197
14198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14200 if (SWIG_arg_fail(1)) SWIG_fail;
14201 {
14202 arg2 = &temp2;
14203 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14204 }
14205 {
14206 arg3 = &temp3;
14207 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14208 }
14209 {
14210 PyThreadState* __tstate = wxPyBeginAllowThreads();
14211 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14212
14213 wxPyEndAllowThreads(__tstate);
14214 if (PyErr_Occurred()) SWIG_fail;
14215 }
14216 Py_INCREF(Py_None); resultobj = Py_None;
14217 return resultobj;
14218 fail:
14219 return NULL;
14220 }
14221
14222
14223 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14224 PyObject *resultobj;
14225 wxDC *arg1 = (wxDC *) 0 ;
14226 wxRegion *arg2 = 0 ;
14227 PyObject * obj0 = 0 ;
14228 PyObject * obj1 = 0 ;
14229 char *kwnames[] = {
14230 (char *) "self",(char *) "region", NULL
14231 };
14232
14233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14235 if (SWIG_arg_fail(1)) SWIG_fail;
14236 {
14237 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14238 if (SWIG_arg_fail(2)) SWIG_fail;
14239 if (arg2 == NULL) {
14240 SWIG_null_ref("wxRegion");
14241 }
14242 if (SWIG_arg_fail(2)) SWIG_fail;
14243 }
14244 {
14245 PyThreadState* __tstate = wxPyBeginAllowThreads();
14246 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14247
14248 wxPyEndAllowThreads(__tstate);
14249 if (PyErr_Occurred()) SWIG_fail;
14250 }
14251 Py_INCREF(Py_None); resultobj = Py_None;
14252 return resultobj;
14253 fail:
14254 return NULL;
14255 }
14256
14257
14258 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14259 PyObject *resultobj;
14260 wxDC *arg1 = (wxDC *) 0 ;
14261 wxRect *arg2 = 0 ;
14262 wxRect temp2 ;
14263 PyObject * obj0 = 0 ;
14264 PyObject * obj1 = 0 ;
14265 char *kwnames[] = {
14266 (char *) "self",(char *) "rect", NULL
14267 };
14268
14269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14271 if (SWIG_arg_fail(1)) SWIG_fail;
14272 {
14273 arg2 = &temp2;
14274 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14275 }
14276 {
14277 PyThreadState* __tstate = wxPyBeginAllowThreads();
14278 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14279
14280 wxPyEndAllowThreads(__tstate);
14281 if (PyErr_Occurred()) SWIG_fail;
14282 }
14283 Py_INCREF(Py_None); resultobj = Py_None;
14284 return resultobj;
14285 fail:
14286 return NULL;
14287 }
14288
14289
14290 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14291 PyObject *resultobj;
14292 wxDC *arg1 = (wxDC *) 0 ;
14293 int arg2 ;
14294 wxPoint *arg3 = (wxPoint *) 0 ;
14295 int arg4 = (int) 0 ;
14296 int arg5 = (int) 0 ;
14297 PyObject * obj0 = 0 ;
14298 PyObject * obj1 = 0 ;
14299 PyObject * obj2 = 0 ;
14300 PyObject * obj3 = 0 ;
14301 char *kwnames[] = {
14302 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14303 };
14304
14305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14307 if (SWIG_arg_fail(1)) SWIG_fail;
14308 {
14309 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14310 if (arg3 == NULL) SWIG_fail;
14311 }
14312 if (obj2) {
14313 {
14314 arg4 = (int)(SWIG_As_int(obj2));
14315 if (SWIG_arg_fail(4)) SWIG_fail;
14316 }
14317 }
14318 if (obj3) {
14319 {
14320 arg5 = (int)(SWIG_As_int(obj3));
14321 if (SWIG_arg_fail(5)) SWIG_fail;
14322 }
14323 }
14324 {
14325 PyThreadState* __tstate = wxPyBeginAllowThreads();
14326 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14327
14328 wxPyEndAllowThreads(__tstate);
14329 if (PyErr_Occurred()) SWIG_fail;
14330 }
14331 Py_INCREF(Py_None); resultobj = Py_None;
14332 {
14333 if (arg3) delete [] arg3;
14334 }
14335 return resultobj;
14336 fail:
14337 {
14338 if (arg3) delete [] arg3;
14339 }
14340 return NULL;
14341 }
14342
14343
14344 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14345 PyObject *resultobj;
14346 wxDC *arg1 = (wxDC *) 0 ;
14347 int arg2 ;
14348 wxPoint *arg3 = (wxPoint *) 0 ;
14349 int arg4 = (int) 0 ;
14350 int arg5 = (int) 0 ;
14351 int arg6 = (int) wxODDEVEN_RULE ;
14352 PyObject * obj0 = 0 ;
14353 PyObject * obj1 = 0 ;
14354 PyObject * obj2 = 0 ;
14355 PyObject * obj3 = 0 ;
14356 PyObject * obj4 = 0 ;
14357 char *kwnames[] = {
14358 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14359 };
14360
14361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14363 if (SWIG_arg_fail(1)) SWIG_fail;
14364 {
14365 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14366 if (arg3 == NULL) SWIG_fail;
14367 }
14368 if (obj2) {
14369 {
14370 arg4 = (int)(SWIG_As_int(obj2));
14371 if (SWIG_arg_fail(4)) SWIG_fail;
14372 }
14373 }
14374 if (obj3) {
14375 {
14376 arg5 = (int)(SWIG_As_int(obj3));
14377 if (SWIG_arg_fail(5)) SWIG_fail;
14378 }
14379 }
14380 if (obj4) {
14381 {
14382 arg6 = (int)(SWIG_As_int(obj4));
14383 if (SWIG_arg_fail(6)) SWIG_fail;
14384 }
14385 }
14386 {
14387 PyThreadState* __tstate = wxPyBeginAllowThreads();
14388 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14389
14390 wxPyEndAllowThreads(__tstate);
14391 if (PyErr_Occurred()) SWIG_fail;
14392 }
14393 Py_INCREF(Py_None); resultobj = Py_None;
14394 {
14395 if (arg3) delete [] arg3;
14396 }
14397 return resultobj;
14398 fail:
14399 {
14400 if (arg3) delete [] arg3;
14401 }
14402 return NULL;
14403 }
14404
14405
14406 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14407 PyObject *resultobj;
14408 wxDC *arg1 = (wxDC *) 0 ;
14409 wxString *arg2 = 0 ;
14410 wxRect *arg3 = 0 ;
14411 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14412 int arg5 = (int) -1 ;
14413 bool temp2 = false ;
14414 wxRect temp3 ;
14415 PyObject * obj0 = 0 ;
14416 PyObject * obj1 = 0 ;
14417 PyObject * obj2 = 0 ;
14418 PyObject * obj3 = 0 ;
14419 PyObject * obj4 = 0 ;
14420 char *kwnames[] = {
14421 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14422 };
14423
14424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14426 if (SWIG_arg_fail(1)) SWIG_fail;
14427 {
14428 arg2 = wxString_in_helper(obj1);
14429 if (arg2 == NULL) SWIG_fail;
14430 temp2 = true;
14431 }
14432 {
14433 arg3 = &temp3;
14434 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
14435 }
14436 if (obj3) {
14437 {
14438 arg4 = (int)(SWIG_As_int(obj3));
14439 if (SWIG_arg_fail(4)) SWIG_fail;
14440 }
14441 }
14442 if (obj4) {
14443 {
14444 arg5 = (int)(SWIG_As_int(obj4));
14445 if (SWIG_arg_fail(5)) SWIG_fail;
14446 }
14447 }
14448 {
14449 PyThreadState* __tstate = wxPyBeginAllowThreads();
14450 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
14451
14452 wxPyEndAllowThreads(__tstate);
14453 if (PyErr_Occurred()) SWIG_fail;
14454 }
14455 Py_INCREF(Py_None); resultobj = Py_None;
14456 {
14457 if (temp2)
14458 delete arg2;
14459 }
14460 return resultobj;
14461 fail:
14462 {
14463 if (temp2)
14464 delete arg2;
14465 }
14466 return NULL;
14467 }
14468
14469
14470 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14471 PyObject *resultobj;
14472 wxDC *arg1 = (wxDC *) 0 ;
14473 wxString *arg2 = 0 ;
14474 wxBitmap *arg3 = 0 ;
14475 wxRect *arg4 = 0 ;
14476 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14477 int arg6 = (int) -1 ;
14478 wxRect result;
14479 bool temp2 = false ;
14480 wxRect temp4 ;
14481 PyObject * obj0 = 0 ;
14482 PyObject * obj1 = 0 ;
14483 PyObject * obj2 = 0 ;
14484 PyObject * obj3 = 0 ;
14485 PyObject * obj4 = 0 ;
14486 PyObject * obj5 = 0 ;
14487 char *kwnames[] = {
14488 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14489 };
14490
14491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14493 if (SWIG_arg_fail(1)) SWIG_fail;
14494 {
14495 arg2 = wxString_in_helper(obj1);
14496 if (arg2 == NULL) SWIG_fail;
14497 temp2 = true;
14498 }
14499 {
14500 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14501 if (SWIG_arg_fail(3)) SWIG_fail;
14502 if (arg3 == NULL) {
14503 SWIG_null_ref("wxBitmap");
14504 }
14505 if (SWIG_arg_fail(3)) SWIG_fail;
14506 }
14507 {
14508 arg4 = &temp4;
14509 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
14510 }
14511 if (obj4) {
14512 {
14513 arg5 = (int)(SWIG_As_int(obj4));
14514 if (SWIG_arg_fail(5)) SWIG_fail;
14515 }
14516 }
14517 if (obj5) {
14518 {
14519 arg6 = (int)(SWIG_As_int(obj5));
14520 if (SWIG_arg_fail(6)) SWIG_fail;
14521 }
14522 }
14523 {
14524 PyThreadState* __tstate = wxPyBeginAllowThreads();
14525 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
14526
14527 wxPyEndAllowThreads(__tstate);
14528 if (PyErr_Occurred()) SWIG_fail;
14529 }
14530 {
14531 wxRect * resultptr;
14532 resultptr = new wxRect((wxRect &)(result));
14533 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14534 }
14535 {
14536 if (temp2)
14537 delete arg2;
14538 }
14539 return resultobj;
14540 fail:
14541 {
14542 if (temp2)
14543 delete arg2;
14544 }
14545 return NULL;
14546 }
14547
14548
14549 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
14550 PyObject *resultobj;
14551 wxDC *arg1 = (wxDC *) 0 ;
14552 int arg2 ;
14553 wxPoint *arg3 = (wxPoint *) 0 ;
14554 PyObject * obj0 = 0 ;
14555 PyObject * obj1 = 0 ;
14556 char *kwnames[] = {
14557 (char *) "self",(char *) "points", NULL
14558 };
14559
14560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
14561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14562 if (SWIG_arg_fail(1)) SWIG_fail;
14563 {
14564 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14565 if (arg3 == NULL) SWIG_fail;
14566 }
14567 {
14568 PyThreadState* __tstate = wxPyBeginAllowThreads();
14569 (arg1)->DrawSpline(arg2,arg3);
14570
14571 wxPyEndAllowThreads(__tstate);
14572 if (PyErr_Occurred()) SWIG_fail;
14573 }
14574 Py_INCREF(Py_None); resultobj = Py_None;
14575 {
14576 if (arg3) delete [] arg3;
14577 }
14578 return resultobj;
14579 fail:
14580 {
14581 if (arg3) delete [] arg3;
14582 }
14583 return NULL;
14584 }
14585
14586
14587 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
14588 PyObject *resultobj;
14589 wxDC *arg1 = (wxDC *) 0 ;
14590 PyObject * obj0 = 0 ;
14591 char *kwnames[] = {
14592 (char *) "self", NULL
14593 };
14594
14595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
14596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14597 if (SWIG_arg_fail(1)) SWIG_fail;
14598 {
14599 PyThreadState* __tstate = wxPyBeginAllowThreads();
14600 (arg1)->Clear();
14601
14602 wxPyEndAllowThreads(__tstate);
14603 if (PyErr_Occurred()) SWIG_fail;
14604 }
14605 Py_INCREF(Py_None); resultobj = Py_None;
14606 return resultobj;
14607 fail:
14608 return NULL;
14609 }
14610
14611
14612 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14613 PyObject *resultobj;
14614 wxDC *arg1 = (wxDC *) 0 ;
14615 wxString *arg2 = 0 ;
14616 bool result;
14617 bool temp2 = false ;
14618 PyObject * obj0 = 0 ;
14619 PyObject * obj1 = 0 ;
14620 char *kwnames[] = {
14621 (char *) "self",(char *) "message", NULL
14622 };
14623
14624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
14625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14626 if (SWIG_arg_fail(1)) SWIG_fail;
14627 {
14628 arg2 = wxString_in_helper(obj1);
14629 if (arg2 == NULL) SWIG_fail;
14630 temp2 = true;
14631 }
14632 {
14633 PyThreadState* __tstate = wxPyBeginAllowThreads();
14634 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
14635
14636 wxPyEndAllowThreads(__tstate);
14637 if (PyErr_Occurred()) SWIG_fail;
14638 }
14639 {
14640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14641 }
14642 {
14643 if (temp2)
14644 delete arg2;
14645 }
14646 return resultobj;
14647 fail:
14648 {
14649 if (temp2)
14650 delete arg2;
14651 }
14652 return NULL;
14653 }
14654
14655
14656 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14657 PyObject *resultobj;
14658 wxDC *arg1 = (wxDC *) 0 ;
14659 PyObject * obj0 = 0 ;
14660 char *kwnames[] = {
14661 (char *) "self", NULL
14662 };
14663
14664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
14665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14666 if (SWIG_arg_fail(1)) SWIG_fail;
14667 {
14668 PyThreadState* __tstate = wxPyBeginAllowThreads();
14669 (arg1)->EndDoc();
14670
14671 wxPyEndAllowThreads(__tstate);
14672 if (PyErr_Occurred()) SWIG_fail;
14673 }
14674 Py_INCREF(Py_None); resultobj = Py_None;
14675 return resultobj;
14676 fail:
14677 return NULL;
14678 }
14679
14680
14681 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
14682 PyObject *resultobj;
14683 wxDC *arg1 = (wxDC *) 0 ;
14684 PyObject * obj0 = 0 ;
14685 char *kwnames[] = {
14686 (char *) "self", NULL
14687 };
14688
14689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
14690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14691 if (SWIG_arg_fail(1)) SWIG_fail;
14692 {
14693 PyThreadState* __tstate = wxPyBeginAllowThreads();
14694 (arg1)->StartPage();
14695
14696 wxPyEndAllowThreads(__tstate);
14697 if (PyErr_Occurred()) SWIG_fail;
14698 }
14699 Py_INCREF(Py_None); resultobj = Py_None;
14700 return resultobj;
14701 fail:
14702 return NULL;
14703 }
14704
14705
14706 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
14707 PyObject *resultobj;
14708 wxDC *arg1 = (wxDC *) 0 ;
14709 PyObject * obj0 = 0 ;
14710 char *kwnames[] = {
14711 (char *) "self", NULL
14712 };
14713
14714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
14715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14716 if (SWIG_arg_fail(1)) SWIG_fail;
14717 {
14718 PyThreadState* __tstate = wxPyBeginAllowThreads();
14719 (arg1)->EndPage();
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_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
14732 PyObject *resultobj;
14733 wxDC *arg1 = (wxDC *) 0 ;
14734 wxFont *arg2 = 0 ;
14735 PyObject * obj0 = 0 ;
14736 PyObject * obj1 = 0 ;
14737 char *kwnames[] = {
14738 (char *) "self",(char *) "font", NULL
14739 };
14740
14741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
14742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14743 if (SWIG_arg_fail(1)) SWIG_fail;
14744 {
14745 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14746 if (SWIG_arg_fail(2)) SWIG_fail;
14747 if (arg2 == NULL) {
14748 SWIG_null_ref("wxFont");
14749 }
14750 if (SWIG_arg_fail(2)) SWIG_fail;
14751 }
14752 {
14753 PyThreadState* __tstate = wxPyBeginAllowThreads();
14754 (arg1)->SetFont((wxFont const &)*arg2);
14755
14756 wxPyEndAllowThreads(__tstate);
14757 if (PyErr_Occurred()) SWIG_fail;
14758 }
14759 Py_INCREF(Py_None); resultobj = Py_None;
14760 return resultobj;
14761 fail:
14762 return NULL;
14763 }
14764
14765
14766 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
14767 PyObject *resultobj;
14768 wxDC *arg1 = (wxDC *) 0 ;
14769 wxPen *arg2 = 0 ;
14770 PyObject * obj0 = 0 ;
14771 PyObject * obj1 = 0 ;
14772 char *kwnames[] = {
14773 (char *) "self",(char *) "pen", NULL
14774 };
14775
14776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
14777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14778 if (SWIG_arg_fail(1)) SWIG_fail;
14779 {
14780 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
14781 if (SWIG_arg_fail(2)) SWIG_fail;
14782 if (arg2 == NULL) {
14783 SWIG_null_ref("wxPen");
14784 }
14785 if (SWIG_arg_fail(2)) SWIG_fail;
14786 }
14787 {
14788 PyThreadState* __tstate = wxPyBeginAllowThreads();
14789 (arg1)->SetPen((wxPen const &)*arg2);
14790
14791 wxPyEndAllowThreads(__tstate);
14792 if (PyErr_Occurred()) SWIG_fail;
14793 }
14794 Py_INCREF(Py_None); resultobj = Py_None;
14795 return resultobj;
14796 fail:
14797 return NULL;
14798 }
14799
14800
14801 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
14802 PyObject *resultobj;
14803 wxDC *arg1 = (wxDC *) 0 ;
14804 wxBrush *arg2 = 0 ;
14805 PyObject * obj0 = 0 ;
14806 PyObject * obj1 = 0 ;
14807 char *kwnames[] = {
14808 (char *) "self",(char *) "brush", NULL
14809 };
14810
14811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
14812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14813 if (SWIG_arg_fail(1)) SWIG_fail;
14814 {
14815 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14816 if (SWIG_arg_fail(2)) SWIG_fail;
14817 if (arg2 == NULL) {
14818 SWIG_null_ref("wxBrush");
14819 }
14820 if (SWIG_arg_fail(2)) SWIG_fail;
14821 }
14822 {
14823 PyThreadState* __tstate = wxPyBeginAllowThreads();
14824 (arg1)->SetBrush((wxBrush const &)*arg2);
14825
14826 wxPyEndAllowThreads(__tstate);
14827 if (PyErr_Occurred()) SWIG_fail;
14828 }
14829 Py_INCREF(Py_None); resultobj = Py_None;
14830 return resultobj;
14831 fail:
14832 return NULL;
14833 }
14834
14835
14836 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
14837 PyObject *resultobj;
14838 wxDC *arg1 = (wxDC *) 0 ;
14839 wxBrush *arg2 = 0 ;
14840 PyObject * obj0 = 0 ;
14841 PyObject * obj1 = 0 ;
14842 char *kwnames[] = {
14843 (char *) "self",(char *) "brush", NULL
14844 };
14845
14846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
14847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14848 if (SWIG_arg_fail(1)) SWIG_fail;
14849 {
14850 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14851 if (SWIG_arg_fail(2)) SWIG_fail;
14852 if (arg2 == NULL) {
14853 SWIG_null_ref("wxBrush");
14854 }
14855 if (SWIG_arg_fail(2)) SWIG_fail;
14856 }
14857 {
14858 PyThreadState* __tstate = wxPyBeginAllowThreads();
14859 (arg1)->SetBackground((wxBrush const &)*arg2);
14860
14861 wxPyEndAllowThreads(__tstate);
14862 if (PyErr_Occurred()) SWIG_fail;
14863 }
14864 Py_INCREF(Py_None); resultobj = Py_None;
14865 return resultobj;
14866 fail:
14867 return NULL;
14868 }
14869
14870
14871 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
14872 PyObject *resultobj;
14873 wxDC *arg1 = (wxDC *) 0 ;
14874 int arg2 ;
14875 PyObject * obj0 = 0 ;
14876 PyObject * obj1 = 0 ;
14877 char *kwnames[] = {
14878 (char *) "self",(char *) "mode", NULL
14879 };
14880
14881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
14882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14883 if (SWIG_arg_fail(1)) SWIG_fail;
14884 {
14885 arg2 = (int)(SWIG_As_int(obj1));
14886 if (SWIG_arg_fail(2)) SWIG_fail;
14887 }
14888 {
14889 PyThreadState* __tstate = wxPyBeginAllowThreads();
14890 (arg1)->SetBackgroundMode(arg2);
14891
14892 wxPyEndAllowThreads(__tstate);
14893 if (PyErr_Occurred()) SWIG_fail;
14894 }
14895 Py_INCREF(Py_None); resultobj = Py_None;
14896 return resultobj;
14897 fail:
14898 return NULL;
14899 }
14900
14901
14902 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
14903 PyObject *resultobj;
14904 wxDC *arg1 = (wxDC *) 0 ;
14905 wxPalette *arg2 = 0 ;
14906 PyObject * obj0 = 0 ;
14907 PyObject * obj1 = 0 ;
14908 char *kwnames[] = {
14909 (char *) "self",(char *) "palette", NULL
14910 };
14911
14912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
14913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14914 if (SWIG_arg_fail(1)) SWIG_fail;
14915 {
14916 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
14917 if (SWIG_arg_fail(2)) SWIG_fail;
14918 if (arg2 == NULL) {
14919 SWIG_null_ref("wxPalette");
14920 }
14921 if (SWIG_arg_fail(2)) SWIG_fail;
14922 }
14923 {
14924 PyThreadState* __tstate = wxPyBeginAllowThreads();
14925 (arg1)->SetPalette((wxPalette const &)*arg2);
14926
14927 wxPyEndAllowThreads(__tstate);
14928 if (PyErr_Occurred()) SWIG_fail;
14929 }
14930 Py_INCREF(Py_None); resultobj = Py_None;
14931 return resultobj;
14932 fail:
14933 return NULL;
14934 }
14935
14936
14937 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14938 PyObject *resultobj;
14939 wxDC *arg1 = (wxDC *) 0 ;
14940 PyObject * obj0 = 0 ;
14941 char *kwnames[] = {
14942 (char *) "self", NULL
14943 };
14944
14945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
14946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14947 if (SWIG_arg_fail(1)) SWIG_fail;
14948 {
14949 PyThreadState* __tstate = wxPyBeginAllowThreads();
14950 (arg1)->DestroyClippingRegion();
14951
14952 wxPyEndAllowThreads(__tstate);
14953 if (PyErr_Occurred()) SWIG_fail;
14954 }
14955 Py_INCREF(Py_None); resultobj = Py_None;
14956 return resultobj;
14957 fail:
14958 return NULL;
14959 }
14960
14961
14962 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
14963 PyObject *resultobj;
14964 wxDC *arg1 = (wxDC *) 0 ;
14965 int *arg2 = (int *) 0 ;
14966 int *arg3 = (int *) 0 ;
14967 int *arg4 = (int *) 0 ;
14968 int *arg5 = (int *) 0 ;
14969 int temp2 ;
14970 int res2 = 0 ;
14971 int temp3 ;
14972 int res3 = 0 ;
14973 int temp4 ;
14974 int res4 = 0 ;
14975 int temp5 ;
14976 int res5 = 0 ;
14977 PyObject * obj0 = 0 ;
14978 char *kwnames[] = {
14979 (char *) "self", NULL
14980 };
14981
14982 arg2 = &temp2; res2 = SWIG_NEWOBJ;
14983 arg3 = &temp3; res3 = SWIG_NEWOBJ;
14984 arg4 = &temp4; res4 = SWIG_NEWOBJ;
14985 arg5 = &temp5; res5 = SWIG_NEWOBJ;
14986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
14987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14988 if (SWIG_arg_fail(1)) SWIG_fail;
14989 {
14990 PyThreadState* __tstate = wxPyBeginAllowThreads();
14991 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
14992
14993 wxPyEndAllowThreads(__tstate);
14994 if (PyErr_Occurred()) SWIG_fail;
14995 }
14996 Py_INCREF(Py_None); resultobj = Py_None;
14997 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
14998 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
14999 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15000 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15001 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15002 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15003 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15004 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15005 return resultobj;
15006 fail:
15007 return NULL;
15008 }
15009
15010
15011 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
15012 PyObject *resultobj;
15013 wxDC *arg1 = (wxDC *) 0 ;
15014 wxRect result;
15015 PyObject * obj0 = 0 ;
15016 char *kwnames[] = {
15017 (char *) "self", NULL
15018 };
15019
15020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
15021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15022 if (SWIG_arg_fail(1)) SWIG_fail;
15023 {
15024 PyThreadState* __tstate = wxPyBeginAllowThreads();
15025 result = wxDC_GetClippingRect(arg1);
15026
15027 wxPyEndAllowThreads(__tstate);
15028 if (PyErr_Occurred()) SWIG_fail;
15029 }
15030 {
15031 wxRect * resultptr;
15032 resultptr = new wxRect((wxRect &)(result));
15033 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15034 }
15035 return resultobj;
15036 fail:
15037 return NULL;
15038 }
15039
15040
15041 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
15042 PyObject *resultobj;
15043 wxDC *arg1 = (wxDC *) 0 ;
15044 int result;
15045 PyObject * obj0 = 0 ;
15046 char *kwnames[] = {
15047 (char *) "self", NULL
15048 };
15049
15050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
15051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15052 if (SWIG_arg_fail(1)) SWIG_fail;
15053 {
15054 PyThreadState* __tstate = wxPyBeginAllowThreads();
15055 result = (int)((wxDC const *)arg1)->GetCharHeight();
15056
15057 wxPyEndAllowThreads(__tstate);
15058 if (PyErr_Occurred()) SWIG_fail;
15059 }
15060 {
15061 resultobj = SWIG_From_int((int)(result));
15062 }
15063 return resultobj;
15064 fail:
15065 return NULL;
15066 }
15067
15068
15069 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
15070 PyObject *resultobj;
15071 wxDC *arg1 = (wxDC *) 0 ;
15072 int result;
15073 PyObject * obj0 = 0 ;
15074 char *kwnames[] = {
15075 (char *) "self", NULL
15076 };
15077
15078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
15079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15080 if (SWIG_arg_fail(1)) SWIG_fail;
15081 {
15082 PyThreadState* __tstate = wxPyBeginAllowThreads();
15083 result = (int)((wxDC const *)arg1)->GetCharWidth();
15084
15085 wxPyEndAllowThreads(__tstate);
15086 if (PyErr_Occurred()) SWIG_fail;
15087 }
15088 {
15089 resultobj = SWIG_From_int((int)(result));
15090 }
15091 return resultobj;
15092 fail:
15093 return NULL;
15094 }
15095
15096
15097 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15098 PyObject *resultobj;
15099 wxDC *arg1 = (wxDC *) 0 ;
15100 wxString *arg2 = 0 ;
15101 int *arg3 = (int *) 0 ;
15102 int *arg4 = (int *) 0 ;
15103 bool temp2 = false ;
15104 int temp3 ;
15105 int res3 = 0 ;
15106 int temp4 ;
15107 int res4 = 0 ;
15108 PyObject * obj0 = 0 ;
15109 PyObject * obj1 = 0 ;
15110 char *kwnames[] = {
15111 (char *) "self",(char *) "string", NULL
15112 };
15113
15114 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15115 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15118 if (SWIG_arg_fail(1)) SWIG_fail;
15119 {
15120 arg2 = wxString_in_helper(obj1);
15121 if (arg2 == NULL) SWIG_fail;
15122 temp2 = true;
15123 }
15124 {
15125 PyThreadState* __tstate = wxPyBeginAllowThreads();
15126 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15127
15128 wxPyEndAllowThreads(__tstate);
15129 if (PyErr_Occurred()) SWIG_fail;
15130 }
15131 Py_INCREF(Py_None); resultobj = Py_None;
15132 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15133 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15134 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15135 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15136 {
15137 if (temp2)
15138 delete arg2;
15139 }
15140 return resultobj;
15141 fail:
15142 {
15143 if (temp2)
15144 delete arg2;
15145 }
15146 return NULL;
15147 }
15148
15149
15150 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15151 PyObject *resultobj;
15152 wxDC *arg1 = (wxDC *) 0 ;
15153 wxString *arg2 = 0 ;
15154 int *arg3 = (int *) 0 ;
15155 int *arg4 = (int *) 0 ;
15156 int *arg5 = (int *) 0 ;
15157 int *arg6 = (int *) 0 ;
15158 wxFont *arg7 = (wxFont *) NULL ;
15159 bool temp2 = false ;
15160 int temp3 ;
15161 int res3 = 0 ;
15162 int temp4 ;
15163 int res4 = 0 ;
15164 int temp5 ;
15165 int res5 = 0 ;
15166 int temp6 ;
15167 int res6 = 0 ;
15168 PyObject * obj0 = 0 ;
15169 PyObject * obj1 = 0 ;
15170 PyObject * obj2 = 0 ;
15171 char *kwnames[] = {
15172 (char *) "self",(char *) "string",(char *) "font", NULL
15173 };
15174
15175 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15176 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15177 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15178 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15181 if (SWIG_arg_fail(1)) SWIG_fail;
15182 {
15183 arg2 = wxString_in_helper(obj1);
15184 if (arg2 == NULL) SWIG_fail;
15185 temp2 = true;
15186 }
15187 if (obj2) {
15188 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15189 if (SWIG_arg_fail(7)) SWIG_fail;
15190 }
15191 {
15192 PyThreadState* __tstate = wxPyBeginAllowThreads();
15193 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15194
15195 wxPyEndAllowThreads(__tstate);
15196 if (PyErr_Occurred()) SWIG_fail;
15197 }
15198 Py_INCREF(Py_None); resultobj = Py_None;
15199 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15200 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15201 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15202 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15203 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15204 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15205 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15206 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15207 {
15208 if (temp2)
15209 delete arg2;
15210 }
15211 return resultobj;
15212 fail:
15213 {
15214 if (temp2)
15215 delete arg2;
15216 }
15217 return NULL;
15218 }
15219
15220
15221 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15222 PyObject *resultobj;
15223 wxDC *arg1 = (wxDC *) 0 ;
15224 wxString *arg2 = 0 ;
15225 int *arg3 = (int *) 0 ;
15226 int *arg4 = (int *) 0 ;
15227 int *arg5 = (int *) 0 ;
15228 wxFont *arg6 = (wxFont *) NULL ;
15229 bool temp2 = false ;
15230 int temp3 ;
15231 int res3 = 0 ;
15232 int temp4 ;
15233 int res4 = 0 ;
15234 int temp5 ;
15235 int res5 = 0 ;
15236 PyObject * obj0 = 0 ;
15237 PyObject * obj1 = 0 ;
15238 PyObject * obj2 = 0 ;
15239 char *kwnames[] = {
15240 (char *) "self",(char *) "text",(char *) "font", NULL
15241 };
15242
15243 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15244 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15245 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15248 if (SWIG_arg_fail(1)) SWIG_fail;
15249 {
15250 arg2 = wxString_in_helper(obj1);
15251 if (arg2 == NULL) SWIG_fail;
15252 temp2 = true;
15253 }
15254 if (obj2) {
15255 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15256 if (SWIG_arg_fail(6)) SWIG_fail;
15257 }
15258 {
15259 PyThreadState* __tstate = wxPyBeginAllowThreads();
15260 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15261
15262 wxPyEndAllowThreads(__tstate);
15263 if (PyErr_Occurred()) SWIG_fail;
15264 }
15265 Py_INCREF(Py_None); resultobj = Py_None;
15266 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15267 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15268 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15269 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15270 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15271 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15272 {
15273 if (temp2)
15274 delete arg2;
15275 }
15276 return resultobj;
15277 fail:
15278 {
15279 if (temp2)
15280 delete arg2;
15281 }
15282 return NULL;
15283 }
15284
15285
15286 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15287 PyObject *resultobj;
15288 wxDC *arg1 = (wxDC *) 0 ;
15289 wxString *arg2 = 0 ;
15290 wxArrayInt result;
15291 bool temp2 = false ;
15292 PyObject * obj0 = 0 ;
15293 PyObject * obj1 = 0 ;
15294 char *kwnames[] = {
15295 (char *) "self",(char *) "text", NULL
15296 };
15297
15298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15300 if (SWIG_arg_fail(1)) SWIG_fail;
15301 {
15302 arg2 = wxString_in_helper(obj1);
15303 if (arg2 == NULL) SWIG_fail;
15304 temp2 = true;
15305 }
15306 {
15307 PyThreadState* __tstate = wxPyBeginAllowThreads();
15308 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15309
15310 wxPyEndAllowThreads(__tstate);
15311 if (PyErr_Occurred()) SWIG_fail;
15312 }
15313 {
15314 resultobj = PyList_New(0);
15315 size_t idx;
15316 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15317 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15318 PyList_Append(resultobj, val);
15319 Py_DECREF(val);
15320 }
15321 }
15322 {
15323 if (temp2)
15324 delete arg2;
15325 }
15326 return resultobj;
15327 fail:
15328 {
15329 if (temp2)
15330 delete arg2;
15331 }
15332 return NULL;
15333 }
15334
15335
15336 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15337 PyObject *resultobj;
15338 wxDC *arg1 = (wxDC *) 0 ;
15339 wxSize result;
15340 PyObject * obj0 = 0 ;
15341 char *kwnames[] = {
15342 (char *) "self", NULL
15343 };
15344
15345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15347 if (SWIG_arg_fail(1)) SWIG_fail;
15348 {
15349 PyThreadState* __tstate = wxPyBeginAllowThreads();
15350 result = (arg1)->GetSize();
15351
15352 wxPyEndAllowThreads(__tstate);
15353 if (PyErr_Occurred()) SWIG_fail;
15354 }
15355 {
15356 wxSize * resultptr;
15357 resultptr = new wxSize((wxSize &)(result));
15358 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15359 }
15360 return resultobj;
15361 fail:
15362 return NULL;
15363 }
15364
15365
15366 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15367 PyObject *resultobj;
15368 wxDC *arg1 = (wxDC *) 0 ;
15369 int *arg2 = (int *) 0 ;
15370 int *arg3 = (int *) 0 ;
15371 int temp2 ;
15372 int res2 = 0 ;
15373 int temp3 ;
15374 int res3 = 0 ;
15375 PyObject * obj0 = 0 ;
15376 char *kwnames[] = {
15377 (char *) "self", NULL
15378 };
15379
15380 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15381 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15384 if (SWIG_arg_fail(1)) SWIG_fail;
15385 {
15386 PyThreadState* __tstate = wxPyBeginAllowThreads();
15387 (arg1)->GetSize(arg2,arg3);
15388
15389 wxPyEndAllowThreads(__tstate);
15390 if (PyErr_Occurred()) SWIG_fail;
15391 }
15392 Py_INCREF(Py_None); resultobj = Py_None;
15393 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15394 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15395 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15396 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15397 return resultobj;
15398 fail:
15399 return NULL;
15400 }
15401
15402
15403 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15404 PyObject *resultobj;
15405 wxDC *arg1 = (wxDC *) 0 ;
15406 wxSize result;
15407 PyObject * obj0 = 0 ;
15408 char *kwnames[] = {
15409 (char *) "self", NULL
15410 };
15411
15412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
15413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15414 if (SWIG_arg_fail(1)) SWIG_fail;
15415 {
15416 PyThreadState* __tstate = wxPyBeginAllowThreads();
15417 result = ((wxDC const *)arg1)->GetSizeMM();
15418
15419 wxPyEndAllowThreads(__tstate);
15420 if (PyErr_Occurred()) SWIG_fail;
15421 }
15422 {
15423 wxSize * resultptr;
15424 resultptr = new wxSize((wxSize &)(result));
15425 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15426 }
15427 return resultobj;
15428 fail:
15429 return NULL;
15430 }
15431
15432
15433 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15434 PyObject *resultobj;
15435 wxDC *arg1 = (wxDC *) 0 ;
15436 int *arg2 = (int *) 0 ;
15437 int *arg3 = (int *) 0 ;
15438 int temp2 ;
15439 int res2 = 0 ;
15440 int temp3 ;
15441 int res3 = 0 ;
15442 PyObject * obj0 = 0 ;
15443 char *kwnames[] = {
15444 (char *) "self", NULL
15445 };
15446
15447 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15448 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
15450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15451 if (SWIG_arg_fail(1)) SWIG_fail;
15452 {
15453 PyThreadState* __tstate = wxPyBeginAllowThreads();
15454 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
15455
15456 wxPyEndAllowThreads(__tstate);
15457 if (PyErr_Occurred()) SWIG_fail;
15458 }
15459 Py_INCREF(Py_None); resultobj = Py_None;
15460 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15461 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15462 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15463 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15464 return resultobj;
15465 fail:
15466 return NULL;
15467 }
15468
15469
15470 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
15471 PyObject *resultobj;
15472 wxDC *arg1 = (wxDC *) 0 ;
15473 int arg2 ;
15474 int result;
15475 PyObject * obj0 = 0 ;
15476 PyObject * obj1 = 0 ;
15477 char *kwnames[] = {
15478 (char *) "self",(char *) "x", NULL
15479 };
15480
15481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
15482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15483 if (SWIG_arg_fail(1)) SWIG_fail;
15484 {
15485 arg2 = (int)(SWIG_As_int(obj1));
15486 if (SWIG_arg_fail(2)) SWIG_fail;
15487 }
15488 {
15489 PyThreadState* __tstate = wxPyBeginAllowThreads();
15490 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
15491
15492 wxPyEndAllowThreads(__tstate);
15493 if (PyErr_Occurred()) SWIG_fail;
15494 }
15495 {
15496 resultobj = SWIG_From_int((int)(result));
15497 }
15498 return resultobj;
15499 fail:
15500 return NULL;
15501 }
15502
15503
15504 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
15505 PyObject *resultobj;
15506 wxDC *arg1 = (wxDC *) 0 ;
15507 int arg2 ;
15508 int result;
15509 PyObject * obj0 = 0 ;
15510 PyObject * obj1 = 0 ;
15511 char *kwnames[] = {
15512 (char *) "self",(char *) "y", NULL
15513 };
15514
15515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
15516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15517 if (SWIG_arg_fail(1)) SWIG_fail;
15518 {
15519 arg2 = (int)(SWIG_As_int(obj1));
15520 if (SWIG_arg_fail(2)) SWIG_fail;
15521 }
15522 {
15523 PyThreadState* __tstate = wxPyBeginAllowThreads();
15524 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
15525
15526 wxPyEndAllowThreads(__tstate);
15527 if (PyErr_Occurred()) SWIG_fail;
15528 }
15529 {
15530 resultobj = SWIG_From_int((int)(result));
15531 }
15532 return resultobj;
15533 fail:
15534 return NULL;
15535 }
15536
15537
15538 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15539 PyObject *resultobj;
15540 wxDC *arg1 = (wxDC *) 0 ;
15541 int arg2 ;
15542 int result;
15543 PyObject * obj0 = 0 ;
15544 PyObject * obj1 = 0 ;
15545 char *kwnames[] = {
15546 (char *) "self",(char *) "x", NULL
15547 };
15548
15549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
15550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15551 if (SWIG_arg_fail(1)) SWIG_fail;
15552 {
15553 arg2 = (int)(SWIG_As_int(obj1));
15554 if (SWIG_arg_fail(2)) SWIG_fail;
15555 }
15556 {
15557 PyThreadState* __tstate = wxPyBeginAllowThreads();
15558 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
15559
15560 wxPyEndAllowThreads(__tstate);
15561 if (PyErr_Occurred()) SWIG_fail;
15562 }
15563 {
15564 resultobj = SWIG_From_int((int)(result));
15565 }
15566 return resultobj;
15567 fail:
15568 return NULL;
15569 }
15570
15571
15572 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15573 PyObject *resultobj;
15574 wxDC *arg1 = (wxDC *) 0 ;
15575 int arg2 ;
15576 int result;
15577 PyObject * obj0 = 0 ;
15578 PyObject * obj1 = 0 ;
15579 char *kwnames[] = {
15580 (char *) "self",(char *) "y", NULL
15581 };
15582
15583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
15584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15585 if (SWIG_arg_fail(1)) SWIG_fail;
15586 {
15587 arg2 = (int)(SWIG_As_int(obj1));
15588 if (SWIG_arg_fail(2)) SWIG_fail;
15589 }
15590 {
15591 PyThreadState* __tstate = wxPyBeginAllowThreads();
15592 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
15593
15594 wxPyEndAllowThreads(__tstate);
15595 if (PyErr_Occurred()) SWIG_fail;
15596 }
15597 {
15598 resultobj = SWIG_From_int((int)(result));
15599 }
15600 return resultobj;
15601 fail:
15602 return NULL;
15603 }
15604
15605
15606 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
15607 PyObject *resultobj;
15608 wxDC *arg1 = (wxDC *) 0 ;
15609 int arg2 ;
15610 int result;
15611 PyObject * obj0 = 0 ;
15612 PyObject * obj1 = 0 ;
15613 char *kwnames[] = {
15614 (char *) "self",(char *) "x", NULL
15615 };
15616
15617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
15618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15619 if (SWIG_arg_fail(1)) SWIG_fail;
15620 {
15621 arg2 = (int)(SWIG_As_int(obj1));
15622 if (SWIG_arg_fail(2)) SWIG_fail;
15623 }
15624 {
15625 PyThreadState* __tstate = wxPyBeginAllowThreads();
15626 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
15627
15628 wxPyEndAllowThreads(__tstate);
15629 if (PyErr_Occurred()) SWIG_fail;
15630 }
15631 {
15632 resultobj = SWIG_From_int((int)(result));
15633 }
15634 return resultobj;
15635 fail:
15636 return NULL;
15637 }
15638
15639
15640 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
15641 PyObject *resultobj;
15642 wxDC *arg1 = (wxDC *) 0 ;
15643 int arg2 ;
15644 int result;
15645 PyObject * obj0 = 0 ;
15646 PyObject * obj1 = 0 ;
15647 char *kwnames[] = {
15648 (char *) "self",(char *) "y", NULL
15649 };
15650
15651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
15652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15653 if (SWIG_arg_fail(1)) SWIG_fail;
15654 {
15655 arg2 = (int)(SWIG_As_int(obj1));
15656 if (SWIG_arg_fail(2)) SWIG_fail;
15657 }
15658 {
15659 PyThreadState* __tstate = wxPyBeginAllowThreads();
15660 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
15661
15662 wxPyEndAllowThreads(__tstate);
15663 if (PyErr_Occurred()) SWIG_fail;
15664 }
15665 {
15666 resultobj = SWIG_From_int((int)(result));
15667 }
15668 return resultobj;
15669 fail:
15670 return NULL;
15671 }
15672
15673
15674 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15675 PyObject *resultobj;
15676 wxDC *arg1 = (wxDC *) 0 ;
15677 int arg2 ;
15678 int result;
15679 PyObject * obj0 = 0 ;
15680 PyObject * obj1 = 0 ;
15681 char *kwnames[] = {
15682 (char *) "self",(char *) "x", NULL
15683 };
15684
15685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
15686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15687 if (SWIG_arg_fail(1)) SWIG_fail;
15688 {
15689 arg2 = (int)(SWIG_As_int(obj1));
15690 if (SWIG_arg_fail(2)) SWIG_fail;
15691 }
15692 {
15693 PyThreadState* __tstate = wxPyBeginAllowThreads();
15694 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
15695
15696 wxPyEndAllowThreads(__tstate);
15697 if (PyErr_Occurred()) SWIG_fail;
15698 }
15699 {
15700 resultobj = SWIG_From_int((int)(result));
15701 }
15702 return resultobj;
15703 fail:
15704 return NULL;
15705 }
15706
15707
15708 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15709 PyObject *resultobj;
15710 wxDC *arg1 = (wxDC *) 0 ;
15711 int arg2 ;
15712 int result;
15713 PyObject * obj0 = 0 ;
15714 PyObject * obj1 = 0 ;
15715 char *kwnames[] = {
15716 (char *) "self",(char *) "y", NULL
15717 };
15718
15719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
15720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15721 if (SWIG_arg_fail(1)) SWIG_fail;
15722 {
15723 arg2 = (int)(SWIG_As_int(obj1));
15724 if (SWIG_arg_fail(2)) SWIG_fail;
15725 }
15726 {
15727 PyThreadState* __tstate = wxPyBeginAllowThreads();
15728 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
15729
15730 wxPyEndAllowThreads(__tstate);
15731 if (PyErr_Occurred()) SWIG_fail;
15732 }
15733 {
15734 resultobj = SWIG_From_int((int)(result));
15735 }
15736 return resultobj;
15737 fail:
15738 return NULL;
15739 }
15740
15741
15742 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
15743 PyObject *resultobj;
15744 wxDC *arg1 = (wxDC *) 0 ;
15745 bool result;
15746 PyObject * obj0 = 0 ;
15747 char *kwnames[] = {
15748 (char *) "self", NULL
15749 };
15750
15751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
15752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15753 if (SWIG_arg_fail(1)) SWIG_fail;
15754 {
15755 PyThreadState* __tstate = wxPyBeginAllowThreads();
15756 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
15757
15758 wxPyEndAllowThreads(__tstate);
15759 if (PyErr_Occurred()) SWIG_fail;
15760 }
15761 {
15762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15763 }
15764 return resultobj;
15765 fail:
15766 return NULL;
15767 }
15768
15769
15770 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15771 PyObject *resultobj;
15772 wxDC *arg1 = (wxDC *) 0 ;
15773 bool result;
15774 PyObject * obj0 = 0 ;
15775 char *kwnames[] = {
15776 (char *) "self", NULL
15777 };
15778
15779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
15780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15781 if (SWIG_arg_fail(1)) SWIG_fail;
15782 {
15783 PyThreadState* __tstate = wxPyBeginAllowThreads();
15784 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
15785
15786 wxPyEndAllowThreads(__tstate);
15787 if (PyErr_Occurred()) SWIG_fail;
15788 }
15789 {
15790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15791 }
15792 return resultobj;
15793 fail:
15794 return NULL;
15795 }
15796
15797
15798 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
15799 PyObject *resultobj;
15800 wxDC *arg1 = (wxDC *) 0 ;
15801 int result;
15802 PyObject * obj0 = 0 ;
15803 char *kwnames[] = {
15804 (char *) "self", NULL
15805 };
15806
15807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
15808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15809 if (SWIG_arg_fail(1)) SWIG_fail;
15810 {
15811 PyThreadState* __tstate = wxPyBeginAllowThreads();
15812 result = (int)((wxDC const *)arg1)->GetDepth();
15813
15814 wxPyEndAllowThreads(__tstate);
15815 if (PyErr_Occurred()) SWIG_fail;
15816 }
15817 {
15818 resultobj = SWIG_From_int((int)(result));
15819 }
15820 return resultobj;
15821 fail:
15822 return NULL;
15823 }
15824
15825
15826 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
15827 PyObject *resultobj;
15828 wxDC *arg1 = (wxDC *) 0 ;
15829 wxSize result;
15830 PyObject * obj0 = 0 ;
15831 char *kwnames[] = {
15832 (char *) "self", NULL
15833 };
15834
15835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
15836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15837 if (SWIG_arg_fail(1)) SWIG_fail;
15838 {
15839 PyThreadState* __tstate = wxPyBeginAllowThreads();
15840 result = ((wxDC const *)arg1)->GetPPI();
15841
15842 wxPyEndAllowThreads(__tstate);
15843 if (PyErr_Occurred()) SWIG_fail;
15844 }
15845 {
15846 wxSize * resultptr;
15847 resultptr = new wxSize((wxSize &)(result));
15848 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15849 }
15850 return resultobj;
15851 fail:
15852 return NULL;
15853 }
15854
15855
15856 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
15857 PyObject *resultobj;
15858 wxDC *arg1 = (wxDC *) 0 ;
15859 bool result;
15860 PyObject * obj0 = 0 ;
15861 char *kwnames[] = {
15862 (char *) "self", NULL
15863 };
15864
15865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
15866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15867 if (SWIG_arg_fail(1)) SWIG_fail;
15868 {
15869 PyThreadState* __tstate = wxPyBeginAllowThreads();
15870 result = (bool)((wxDC const *)arg1)->Ok();
15871
15872 wxPyEndAllowThreads(__tstate);
15873 if (PyErr_Occurred()) SWIG_fail;
15874 }
15875 {
15876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15877 }
15878 return resultobj;
15879 fail:
15880 return NULL;
15881 }
15882
15883
15884 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15885 PyObject *resultobj;
15886 wxDC *arg1 = (wxDC *) 0 ;
15887 int result;
15888 PyObject * obj0 = 0 ;
15889 char *kwnames[] = {
15890 (char *) "self", NULL
15891 };
15892
15893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
15894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15895 if (SWIG_arg_fail(1)) SWIG_fail;
15896 {
15897 PyThreadState* __tstate = wxPyBeginAllowThreads();
15898 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
15899
15900 wxPyEndAllowThreads(__tstate);
15901 if (PyErr_Occurred()) SWIG_fail;
15902 }
15903 {
15904 resultobj = SWIG_From_int((int)(result));
15905 }
15906 return resultobj;
15907 fail:
15908 return NULL;
15909 }
15910
15911
15912 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15913 PyObject *resultobj;
15914 wxDC *arg1 = (wxDC *) 0 ;
15915 wxBrush *result;
15916 PyObject * obj0 = 0 ;
15917 char *kwnames[] = {
15918 (char *) "self", NULL
15919 };
15920
15921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
15922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15923 if (SWIG_arg_fail(1)) SWIG_fail;
15924 {
15925 PyThreadState* __tstate = wxPyBeginAllowThreads();
15926 {
15927 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
15928 result = (wxBrush *) &_result_ref;
15929 }
15930
15931 wxPyEndAllowThreads(__tstate);
15932 if (PyErr_Occurred()) SWIG_fail;
15933 }
15934 {
15935 wxBrush* resultptr = new wxBrush(*result);
15936 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15937 }
15938 return resultobj;
15939 fail:
15940 return NULL;
15941 }
15942
15943
15944 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15945 PyObject *resultobj;
15946 wxDC *arg1 = (wxDC *) 0 ;
15947 wxBrush *result;
15948 PyObject * obj0 = 0 ;
15949 char *kwnames[] = {
15950 (char *) "self", NULL
15951 };
15952
15953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
15954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15955 if (SWIG_arg_fail(1)) SWIG_fail;
15956 {
15957 PyThreadState* __tstate = wxPyBeginAllowThreads();
15958 {
15959 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
15960 result = (wxBrush *) &_result_ref;
15961 }
15962
15963 wxPyEndAllowThreads(__tstate);
15964 if (PyErr_Occurred()) SWIG_fail;
15965 }
15966 {
15967 wxBrush* resultptr = new wxBrush(*result);
15968 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15969 }
15970 return resultobj;
15971 fail:
15972 return NULL;
15973 }
15974
15975
15976 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15977 PyObject *resultobj;
15978 wxDC *arg1 = (wxDC *) 0 ;
15979 wxFont *result;
15980 PyObject * obj0 = 0 ;
15981 char *kwnames[] = {
15982 (char *) "self", NULL
15983 };
15984
15985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
15986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15987 if (SWIG_arg_fail(1)) SWIG_fail;
15988 {
15989 PyThreadState* __tstate = wxPyBeginAllowThreads();
15990 {
15991 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
15992 result = (wxFont *) &_result_ref;
15993 }
15994
15995 wxPyEndAllowThreads(__tstate);
15996 if (PyErr_Occurred()) SWIG_fail;
15997 }
15998 {
15999 wxFont* resultptr = new wxFont(*result);
16000 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
16001 }
16002 return resultobj;
16003 fail:
16004 return NULL;
16005 }
16006
16007
16008 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
16009 PyObject *resultobj;
16010 wxDC *arg1 = (wxDC *) 0 ;
16011 wxPen *result;
16012 PyObject * obj0 = 0 ;
16013 char *kwnames[] = {
16014 (char *) "self", NULL
16015 };
16016
16017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
16018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16019 if (SWIG_arg_fail(1)) SWIG_fail;
16020 {
16021 PyThreadState* __tstate = wxPyBeginAllowThreads();
16022 {
16023 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
16024 result = (wxPen *) &_result_ref;
16025 }
16026
16027 wxPyEndAllowThreads(__tstate);
16028 if (PyErr_Occurred()) SWIG_fail;
16029 }
16030 {
16031 wxPen* resultptr = new wxPen(*result);
16032 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
16033 }
16034 return resultobj;
16035 fail:
16036 return NULL;
16037 }
16038
16039
16040 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16041 PyObject *resultobj;
16042 wxDC *arg1 = (wxDC *) 0 ;
16043 wxColour *result;
16044 PyObject * obj0 = 0 ;
16045 char *kwnames[] = {
16046 (char *) "self", NULL
16047 };
16048
16049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
16050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16051 if (SWIG_arg_fail(1)) SWIG_fail;
16052 {
16053 PyThreadState* __tstate = wxPyBeginAllowThreads();
16054 {
16055 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
16056 result = (wxColour *) &_result_ref;
16057 }
16058
16059 wxPyEndAllowThreads(__tstate);
16060 if (PyErr_Occurred()) SWIG_fail;
16061 }
16062 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16063 return resultobj;
16064 fail:
16065 return NULL;
16066 }
16067
16068
16069 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16070 PyObject *resultobj;
16071 wxDC *arg1 = (wxDC *) 0 ;
16072 wxColour *result;
16073 PyObject * obj0 = 0 ;
16074 char *kwnames[] = {
16075 (char *) "self", NULL
16076 };
16077
16078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
16079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16080 if (SWIG_arg_fail(1)) SWIG_fail;
16081 {
16082 PyThreadState* __tstate = wxPyBeginAllowThreads();
16083 {
16084 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
16085 result = (wxColour *) &_result_ref;
16086 }
16087
16088 wxPyEndAllowThreads(__tstate);
16089 if (PyErr_Occurred()) SWIG_fail;
16090 }
16091 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16092 return resultobj;
16093 fail:
16094 return NULL;
16095 }
16096
16097
16098 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16099 PyObject *resultobj;
16100 wxDC *arg1 = (wxDC *) 0 ;
16101 wxColour *arg2 = 0 ;
16102 wxColour temp2 ;
16103 PyObject * obj0 = 0 ;
16104 PyObject * obj1 = 0 ;
16105 char *kwnames[] = {
16106 (char *) "self",(char *) "colour", NULL
16107 };
16108
16109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16111 if (SWIG_arg_fail(1)) SWIG_fail;
16112 {
16113 arg2 = &temp2;
16114 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16115 }
16116 {
16117 PyThreadState* __tstate = wxPyBeginAllowThreads();
16118 (arg1)->SetTextForeground((wxColour const &)*arg2);
16119
16120 wxPyEndAllowThreads(__tstate);
16121 if (PyErr_Occurred()) SWIG_fail;
16122 }
16123 Py_INCREF(Py_None); resultobj = Py_None;
16124 return resultobj;
16125 fail:
16126 return NULL;
16127 }
16128
16129
16130 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16131 PyObject *resultobj;
16132 wxDC *arg1 = (wxDC *) 0 ;
16133 wxColour *arg2 = 0 ;
16134 wxColour temp2 ;
16135 PyObject * obj0 = 0 ;
16136 PyObject * obj1 = 0 ;
16137 char *kwnames[] = {
16138 (char *) "self",(char *) "colour", NULL
16139 };
16140
16141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16143 if (SWIG_arg_fail(1)) SWIG_fail;
16144 {
16145 arg2 = &temp2;
16146 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16147 }
16148 {
16149 PyThreadState* __tstate = wxPyBeginAllowThreads();
16150 (arg1)->SetTextBackground((wxColour const &)*arg2);
16151
16152 wxPyEndAllowThreads(__tstate);
16153 if (PyErr_Occurred()) SWIG_fail;
16154 }
16155 Py_INCREF(Py_None); resultobj = Py_None;
16156 return resultobj;
16157 fail:
16158 return NULL;
16159 }
16160
16161
16162 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16163 PyObject *resultobj;
16164 wxDC *arg1 = (wxDC *) 0 ;
16165 int result;
16166 PyObject * obj0 = 0 ;
16167 char *kwnames[] = {
16168 (char *) "self", NULL
16169 };
16170
16171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16173 if (SWIG_arg_fail(1)) SWIG_fail;
16174 {
16175 PyThreadState* __tstate = wxPyBeginAllowThreads();
16176 result = (int)((wxDC const *)arg1)->GetMapMode();
16177
16178 wxPyEndAllowThreads(__tstate);
16179 if (PyErr_Occurred()) SWIG_fail;
16180 }
16181 {
16182 resultobj = SWIG_From_int((int)(result));
16183 }
16184 return resultobj;
16185 fail:
16186 return NULL;
16187 }
16188
16189
16190 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16191 PyObject *resultobj;
16192 wxDC *arg1 = (wxDC *) 0 ;
16193 int arg2 ;
16194 PyObject * obj0 = 0 ;
16195 PyObject * obj1 = 0 ;
16196 char *kwnames[] = {
16197 (char *) "self",(char *) "mode", NULL
16198 };
16199
16200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16202 if (SWIG_arg_fail(1)) SWIG_fail;
16203 {
16204 arg2 = (int)(SWIG_As_int(obj1));
16205 if (SWIG_arg_fail(2)) SWIG_fail;
16206 }
16207 {
16208 PyThreadState* __tstate = wxPyBeginAllowThreads();
16209 (arg1)->SetMapMode(arg2);
16210
16211 wxPyEndAllowThreads(__tstate);
16212 if (PyErr_Occurred()) SWIG_fail;
16213 }
16214 Py_INCREF(Py_None); resultobj = Py_None;
16215 return resultobj;
16216 fail:
16217 return NULL;
16218 }
16219
16220
16221 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16222 PyObject *resultobj;
16223 wxDC *arg1 = (wxDC *) 0 ;
16224 double *arg2 = (double *) 0 ;
16225 double *arg3 = (double *) 0 ;
16226 double temp2 ;
16227 int res2 = 0 ;
16228 double temp3 ;
16229 int res3 = 0 ;
16230 PyObject * obj0 = 0 ;
16231 char *kwnames[] = {
16232 (char *) "self", NULL
16233 };
16234
16235 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16236 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16239 if (SWIG_arg_fail(1)) SWIG_fail;
16240 {
16241 PyThreadState* __tstate = wxPyBeginAllowThreads();
16242 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16243
16244 wxPyEndAllowThreads(__tstate);
16245 if (PyErr_Occurred()) SWIG_fail;
16246 }
16247 Py_INCREF(Py_None); resultobj = Py_None;
16248 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16249 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16250 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16251 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16252 return resultobj;
16253 fail:
16254 return NULL;
16255 }
16256
16257
16258 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16259 PyObject *resultobj;
16260 wxDC *arg1 = (wxDC *) 0 ;
16261 double arg2 ;
16262 double arg3 ;
16263 PyObject * obj0 = 0 ;
16264 PyObject * obj1 = 0 ;
16265 PyObject * obj2 = 0 ;
16266 char *kwnames[] = {
16267 (char *) "self",(char *) "x",(char *) "y", NULL
16268 };
16269
16270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16272 if (SWIG_arg_fail(1)) SWIG_fail;
16273 {
16274 arg2 = (double)(SWIG_As_double(obj1));
16275 if (SWIG_arg_fail(2)) SWIG_fail;
16276 }
16277 {
16278 arg3 = (double)(SWIG_As_double(obj2));
16279 if (SWIG_arg_fail(3)) SWIG_fail;
16280 }
16281 {
16282 PyThreadState* __tstate = wxPyBeginAllowThreads();
16283 (arg1)->SetUserScale(arg2,arg3);
16284
16285 wxPyEndAllowThreads(__tstate);
16286 if (PyErr_Occurred()) SWIG_fail;
16287 }
16288 Py_INCREF(Py_None); resultobj = Py_None;
16289 return resultobj;
16290 fail:
16291 return NULL;
16292 }
16293
16294
16295 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16296 PyObject *resultobj;
16297 wxDC *arg1 = (wxDC *) 0 ;
16298 double *arg2 = (double *) 0 ;
16299 double *arg3 = (double *) 0 ;
16300 double temp2 ;
16301 int res2 = 0 ;
16302 double temp3 ;
16303 int res3 = 0 ;
16304 PyObject * obj0 = 0 ;
16305 char *kwnames[] = {
16306 (char *) "self", NULL
16307 };
16308
16309 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16310 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16313 if (SWIG_arg_fail(1)) SWIG_fail;
16314 {
16315 PyThreadState* __tstate = wxPyBeginAllowThreads();
16316 (arg1)->GetLogicalScale(arg2,arg3);
16317
16318 wxPyEndAllowThreads(__tstate);
16319 if (PyErr_Occurred()) SWIG_fail;
16320 }
16321 Py_INCREF(Py_None); resultobj = Py_None;
16322 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16323 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16324 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16325 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16326 return resultobj;
16327 fail:
16328 return NULL;
16329 }
16330
16331
16332 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16333 PyObject *resultobj;
16334 wxDC *arg1 = (wxDC *) 0 ;
16335 double arg2 ;
16336 double arg3 ;
16337 PyObject * obj0 = 0 ;
16338 PyObject * obj1 = 0 ;
16339 PyObject * obj2 = 0 ;
16340 char *kwnames[] = {
16341 (char *) "self",(char *) "x",(char *) "y", NULL
16342 };
16343
16344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16346 if (SWIG_arg_fail(1)) SWIG_fail;
16347 {
16348 arg2 = (double)(SWIG_As_double(obj1));
16349 if (SWIG_arg_fail(2)) SWIG_fail;
16350 }
16351 {
16352 arg3 = (double)(SWIG_As_double(obj2));
16353 if (SWIG_arg_fail(3)) SWIG_fail;
16354 }
16355 {
16356 PyThreadState* __tstate = wxPyBeginAllowThreads();
16357 (arg1)->SetLogicalScale(arg2,arg3);
16358
16359 wxPyEndAllowThreads(__tstate);
16360 if (PyErr_Occurred()) SWIG_fail;
16361 }
16362 Py_INCREF(Py_None); resultobj = Py_None;
16363 return resultobj;
16364 fail:
16365 return NULL;
16366 }
16367
16368
16369 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16370 PyObject *resultobj;
16371 wxDC *arg1 = (wxDC *) 0 ;
16372 wxPoint result;
16373 PyObject * obj0 = 0 ;
16374 char *kwnames[] = {
16375 (char *) "self", NULL
16376 };
16377
16378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16380 if (SWIG_arg_fail(1)) SWIG_fail;
16381 {
16382 PyThreadState* __tstate = wxPyBeginAllowThreads();
16383 result = ((wxDC const *)arg1)->GetLogicalOrigin();
16384
16385 wxPyEndAllowThreads(__tstate);
16386 if (PyErr_Occurred()) SWIG_fail;
16387 }
16388 {
16389 wxPoint * resultptr;
16390 resultptr = new wxPoint((wxPoint &)(result));
16391 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16392 }
16393 return resultobj;
16394 fail:
16395 return NULL;
16396 }
16397
16398
16399 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16400 PyObject *resultobj;
16401 wxDC *arg1 = (wxDC *) 0 ;
16402 int *arg2 = (int *) 0 ;
16403 int *arg3 = (int *) 0 ;
16404 int temp2 ;
16405 int res2 = 0 ;
16406 int temp3 ;
16407 int res3 = 0 ;
16408 PyObject * obj0 = 0 ;
16409 char *kwnames[] = {
16410 (char *) "self", NULL
16411 };
16412
16413 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16414 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
16416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16417 if (SWIG_arg_fail(1)) SWIG_fail;
16418 {
16419 PyThreadState* __tstate = wxPyBeginAllowThreads();
16420 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
16421
16422 wxPyEndAllowThreads(__tstate);
16423 if (PyErr_Occurred()) SWIG_fail;
16424 }
16425 Py_INCREF(Py_None); resultobj = Py_None;
16426 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16427 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16428 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16429 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16430 return resultobj;
16431 fail:
16432 return NULL;
16433 }
16434
16435
16436 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16437 PyObject *resultobj;
16438 wxDC *arg1 = (wxDC *) 0 ;
16439 int arg2 ;
16440 int arg3 ;
16441 PyObject * obj0 = 0 ;
16442 PyObject * obj1 = 0 ;
16443 PyObject * obj2 = 0 ;
16444 char *kwnames[] = {
16445 (char *) "self",(char *) "x",(char *) "y", NULL
16446 };
16447
16448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16450 if (SWIG_arg_fail(1)) SWIG_fail;
16451 {
16452 arg2 = (int)(SWIG_As_int(obj1));
16453 if (SWIG_arg_fail(2)) SWIG_fail;
16454 }
16455 {
16456 arg3 = (int)(SWIG_As_int(obj2));
16457 if (SWIG_arg_fail(3)) SWIG_fail;
16458 }
16459 {
16460 PyThreadState* __tstate = wxPyBeginAllowThreads();
16461 (arg1)->SetLogicalOrigin(arg2,arg3);
16462
16463 wxPyEndAllowThreads(__tstate);
16464 if (PyErr_Occurred()) SWIG_fail;
16465 }
16466 Py_INCREF(Py_None); resultobj = Py_None;
16467 return resultobj;
16468 fail:
16469 return NULL;
16470 }
16471
16472
16473 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16474 PyObject *resultobj;
16475 wxDC *arg1 = (wxDC *) 0 ;
16476 wxPoint *arg2 = 0 ;
16477 wxPoint temp2 ;
16478 PyObject * obj0 = 0 ;
16479 PyObject * obj1 = 0 ;
16480 char *kwnames[] = {
16481 (char *) "self",(char *) "point", NULL
16482 };
16483
16484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16486 if (SWIG_arg_fail(1)) SWIG_fail;
16487 {
16488 arg2 = &temp2;
16489 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16490 }
16491 {
16492 PyThreadState* __tstate = wxPyBeginAllowThreads();
16493 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
16494
16495 wxPyEndAllowThreads(__tstate);
16496 if (PyErr_Occurred()) SWIG_fail;
16497 }
16498 Py_INCREF(Py_None); resultobj = Py_None;
16499 return resultobj;
16500 fail:
16501 return NULL;
16502 }
16503
16504
16505 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16506 PyObject *resultobj;
16507 wxDC *arg1 = (wxDC *) 0 ;
16508 wxPoint result;
16509 PyObject * obj0 = 0 ;
16510 char *kwnames[] = {
16511 (char *) "self", NULL
16512 };
16513
16514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
16515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16516 if (SWIG_arg_fail(1)) SWIG_fail;
16517 {
16518 PyThreadState* __tstate = wxPyBeginAllowThreads();
16519 result = ((wxDC const *)arg1)->GetDeviceOrigin();
16520
16521 wxPyEndAllowThreads(__tstate);
16522 if (PyErr_Occurred()) SWIG_fail;
16523 }
16524 {
16525 wxPoint * resultptr;
16526 resultptr = new wxPoint((wxPoint &)(result));
16527 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16528 }
16529 return resultobj;
16530 fail:
16531 return NULL;
16532 }
16533
16534
16535 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16536 PyObject *resultobj;
16537 wxDC *arg1 = (wxDC *) 0 ;
16538 int *arg2 = (int *) 0 ;
16539 int *arg3 = (int *) 0 ;
16540 int temp2 ;
16541 int res2 = 0 ;
16542 int temp3 ;
16543 int res3 = 0 ;
16544 PyObject * obj0 = 0 ;
16545 char *kwnames[] = {
16546 (char *) "self", NULL
16547 };
16548
16549 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16550 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
16552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16553 if (SWIG_arg_fail(1)) SWIG_fail;
16554 {
16555 PyThreadState* __tstate = wxPyBeginAllowThreads();
16556 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
16557
16558 wxPyEndAllowThreads(__tstate);
16559 if (PyErr_Occurred()) SWIG_fail;
16560 }
16561 Py_INCREF(Py_None); resultobj = Py_None;
16562 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16563 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16564 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16565 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16566 return resultobj;
16567 fail:
16568 return NULL;
16569 }
16570
16571
16572 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16573 PyObject *resultobj;
16574 wxDC *arg1 = (wxDC *) 0 ;
16575 int arg2 ;
16576 int arg3 ;
16577 PyObject * obj0 = 0 ;
16578 PyObject * obj1 = 0 ;
16579 PyObject * obj2 = 0 ;
16580 char *kwnames[] = {
16581 (char *) "self",(char *) "x",(char *) "y", NULL
16582 };
16583
16584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16586 if (SWIG_arg_fail(1)) SWIG_fail;
16587 {
16588 arg2 = (int)(SWIG_As_int(obj1));
16589 if (SWIG_arg_fail(2)) SWIG_fail;
16590 }
16591 {
16592 arg3 = (int)(SWIG_As_int(obj2));
16593 if (SWIG_arg_fail(3)) SWIG_fail;
16594 }
16595 {
16596 PyThreadState* __tstate = wxPyBeginAllowThreads();
16597 (arg1)->SetDeviceOrigin(arg2,arg3);
16598
16599 wxPyEndAllowThreads(__tstate);
16600 if (PyErr_Occurred()) SWIG_fail;
16601 }
16602 Py_INCREF(Py_None); resultobj = Py_None;
16603 return resultobj;
16604 fail:
16605 return NULL;
16606 }
16607
16608
16609 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16610 PyObject *resultobj;
16611 wxDC *arg1 = (wxDC *) 0 ;
16612 wxPoint *arg2 = 0 ;
16613 wxPoint temp2 ;
16614 PyObject * obj0 = 0 ;
16615 PyObject * obj1 = 0 ;
16616 char *kwnames[] = {
16617 (char *) "self",(char *) "point", NULL
16618 };
16619
16620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16622 if (SWIG_arg_fail(1)) SWIG_fail;
16623 {
16624 arg2 = &temp2;
16625 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16626 }
16627 {
16628 PyThreadState* __tstate = wxPyBeginAllowThreads();
16629 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
16630
16631 wxPyEndAllowThreads(__tstate);
16632 if (PyErr_Occurred()) SWIG_fail;
16633 }
16634 Py_INCREF(Py_None); resultobj = Py_None;
16635 return resultobj;
16636 fail:
16637 return NULL;
16638 }
16639
16640
16641 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16642 PyObject *resultobj;
16643 wxDC *arg1 = (wxDC *) 0 ;
16644 bool arg2 ;
16645 bool arg3 ;
16646 PyObject * obj0 = 0 ;
16647 PyObject * obj1 = 0 ;
16648 PyObject * obj2 = 0 ;
16649 char *kwnames[] = {
16650 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
16651 };
16652
16653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
16654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16655 if (SWIG_arg_fail(1)) SWIG_fail;
16656 {
16657 arg2 = (bool)(SWIG_As_bool(obj1));
16658 if (SWIG_arg_fail(2)) SWIG_fail;
16659 }
16660 {
16661 arg3 = (bool)(SWIG_As_bool(obj2));
16662 if (SWIG_arg_fail(3)) SWIG_fail;
16663 }
16664 {
16665 PyThreadState* __tstate = wxPyBeginAllowThreads();
16666 (arg1)->SetAxisOrientation(arg2,arg3);
16667
16668 wxPyEndAllowThreads(__tstate);
16669 if (PyErr_Occurred()) SWIG_fail;
16670 }
16671 Py_INCREF(Py_None); resultobj = Py_None;
16672 return resultobj;
16673 fail:
16674 return NULL;
16675 }
16676
16677
16678 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16679 PyObject *resultobj;
16680 wxDC *arg1 = (wxDC *) 0 ;
16681 int result;
16682 PyObject * obj0 = 0 ;
16683 char *kwnames[] = {
16684 (char *) "self", NULL
16685 };
16686
16687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
16688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16689 if (SWIG_arg_fail(1)) SWIG_fail;
16690 {
16691 PyThreadState* __tstate = wxPyBeginAllowThreads();
16692 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
16693
16694 wxPyEndAllowThreads(__tstate);
16695 if (PyErr_Occurred()) SWIG_fail;
16696 }
16697 {
16698 resultobj = SWIG_From_int((int)(result));
16699 }
16700 return resultobj;
16701 fail:
16702 return NULL;
16703 }
16704
16705
16706 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16707 PyObject *resultobj;
16708 wxDC *arg1 = (wxDC *) 0 ;
16709 int arg2 ;
16710 PyObject * obj0 = 0 ;
16711 PyObject * obj1 = 0 ;
16712 char *kwnames[] = {
16713 (char *) "self",(char *) "function", NULL
16714 };
16715
16716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
16717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16718 if (SWIG_arg_fail(1)) SWIG_fail;
16719 {
16720 arg2 = (int)(SWIG_As_int(obj1));
16721 if (SWIG_arg_fail(2)) SWIG_fail;
16722 }
16723 {
16724 PyThreadState* __tstate = wxPyBeginAllowThreads();
16725 (arg1)->SetLogicalFunction(arg2);
16726
16727 wxPyEndAllowThreads(__tstate);
16728 if (PyErr_Occurred()) SWIG_fail;
16729 }
16730 Py_INCREF(Py_None); resultobj = Py_None;
16731 return resultobj;
16732 fail:
16733 return NULL;
16734 }
16735
16736
16737 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16738 PyObject *resultobj;
16739 wxDC *arg1 = (wxDC *) 0 ;
16740 PyObject * obj0 = 0 ;
16741 char *kwnames[] = {
16742 (char *) "self", NULL
16743 };
16744
16745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
16746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16747 if (SWIG_arg_fail(1)) SWIG_fail;
16748 {
16749 PyThreadState* __tstate = wxPyBeginAllowThreads();
16750 (arg1)->ComputeScaleAndOrigin();
16751
16752 wxPyEndAllowThreads(__tstate);
16753 if (PyErr_Occurred()) SWIG_fail;
16754 }
16755 Py_INCREF(Py_None); resultobj = Py_None;
16756 return resultobj;
16757 fail:
16758 return NULL;
16759 }
16760
16761
16762 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16763 PyObject *resultobj;
16764 wxDC *arg1 = (wxDC *) 0 ;
16765 int arg2 ;
16766 int arg3 ;
16767 PyObject * obj0 = 0 ;
16768 PyObject * obj1 = 0 ;
16769 PyObject * obj2 = 0 ;
16770 char *kwnames[] = {
16771 (char *) "self",(char *) "x",(char *) "y", NULL
16772 };
16773
16774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
16775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16776 if (SWIG_arg_fail(1)) SWIG_fail;
16777 {
16778 arg2 = (int)(SWIG_As_int(obj1));
16779 if (SWIG_arg_fail(2)) SWIG_fail;
16780 }
16781 {
16782 arg3 = (int)(SWIG_As_int(obj2));
16783 if (SWIG_arg_fail(3)) SWIG_fail;
16784 }
16785 {
16786 PyThreadState* __tstate = wxPyBeginAllowThreads();
16787 (arg1)->CalcBoundingBox(arg2,arg3);
16788
16789 wxPyEndAllowThreads(__tstate);
16790 if (PyErr_Occurred()) SWIG_fail;
16791 }
16792 Py_INCREF(Py_None); resultobj = Py_None;
16793 return resultobj;
16794 fail:
16795 return NULL;
16796 }
16797
16798
16799 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16800 PyObject *resultobj;
16801 wxDC *arg1 = (wxDC *) 0 ;
16802 wxPoint *arg2 = 0 ;
16803 wxPoint temp2 ;
16804 PyObject * obj0 = 0 ;
16805 PyObject * obj1 = 0 ;
16806 char *kwnames[] = {
16807 (char *) "self",(char *) "point", NULL
16808 };
16809
16810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
16811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16812 if (SWIG_arg_fail(1)) SWIG_fail;
16813 {
16814 arg2 = &temp2;
16815 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16816 }
16817 {
16818 PyThreadState* __tstate = wxPyBeginAllowThreads();
16819 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
16820
16821 wxPyEndAllowThreads(__tstate);
16822 if (PyErr_Occurred()) SWIG_fail;
16823 }
16824 Py_INCREF(Py_None); resultobj = Py_None;
16825 return resultobj;
16826 fail:
16827 return NULL;
16828 }
16829
16830
16831 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16832 PyObject *resultobj;
16833 wxDC *arg1 = (wxDC *) 0 ;
16834 PyObject * obj0 = 0 ;
16835 char *kwnames[] = {
16836 (char *) "self", NULL
16837 };
16838
16839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
16840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16841 if (SWIG_arg_fail(1)) SWIG_fail;
16842 {
16843 PyThreadState* __tstate = wxPyBeginAllowThreads();
16844 (arg1)->ResetBoundingBox();
16845
16846 wxPyEndAllowThreads(__tstate);
16847 if (PyErr_Occurred()) SWIG_fail;
16848 }
16849 Py_INCREF(Py_None); resultobj = Py_None;
16850 return resultobj;
16851 fail:
16852 return NULL;
16853 }
16854
16855
16856 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
16857 PyObject *resultobj;
16858 wxDC *arg1 = (wxDC *) 0 ;
16859 int result;
16860 PyObject * obj0 = 0 ;
16861 char *kwnames[] = {
16862 (char *) "self", NULL
16863 };
16864
16865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
16866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16867 if (SWIG_arg_fail(1)) SWIG_fail;
16868 {
16869 PyThreadState* __tstate = wxPyBeginAllowThreads();
16870 result = (int)((wxDC const *)arg1)->MinX();
16871
16872 wxPyEndAllowThreads(__tstate);
16873 if (PyErr_Occurred()) SWIG_fail;
16874 }
16875 {
16876 resultobj = SWIG_From_int((int)(result));
16877 }
16878 return resultobj;
16879 fail:
16880 return NULL;
16881 }
16882
16883
16884 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
16885 PyObject *resultobj;
16886 wxDC *arg1 = (wxDC *) 0 ;
16887 int result;
16888 PyObject * obj0 = 0 ;
16889 char *kwnames[] = {
16890 (char *) "self", NULL
16891 };
16892
16893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
16894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16895 if (SWIG_arg_fail(1)) SWIG_fail;
16896 {
16897 PyThreadState* __tstate = wxPyBeginAllowThreads();
16898 result = (int)((wxDC const *)arg1)->MaxX();
16899
16900 wxPyEndAllowThreads(__tstate);
16901 if (PyErr_Occurred()) SWIG_fail;
16902 }
16903 {
16904 resultobj = SWIG_From_int((int)(result));
16905 }
16906 return resultobj;
16907 fail:
16908 return NULL;
16909 }
16910
16911
16912 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
16913 PyObject *resultobj;
16914 wxDC *arg1 = (wxDC *) 0 ;
16915 int result;
16916 PyObject * obj0 = 0 ;
16917 char *kwnames[] = {
16918 (char *) "self", NULL
16919 };
16920
16921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
16922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16923 if (SWIG_arg_fail(1)) SWIG_fail;
16924 {
16925 PyThreadState* __tstate = wxPyBeginAllowThreads();
16926 result = (int)((wxDC const *)arg1)->MinY();
16927
16928 wxPyEndAllowThreads(__tstate);
16929 if (PyErr_Occurred()) SWIG_fail;
16930 }
16931 {
16932 resultobj = SWIG_From_int((int)(result));
16933 }
16934 return resultobj;
16935 fail:
16936 return NULL;
16937 }
16938
16939
16940 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
16941 PyObject *resultobj;
16942 wxDC *arg1 = (wxDC *) 0 ;
16943 int result;
16944 PyObject * obj0 = 0 ;
16945 char *kwnames[] = {
16946 (char *) "self", NULL
16947 };
16948
16949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
16950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16951 if (SWIG_arg_fail(1)) SWIG_fail;
16952 {
16953 PyThreadState* __tstate = wxPyBeginAllowThreads();
16954 result = (int)((wxDC const *)arg1)->MaxY();
16955
16956 wxPyEndAllowThreads(__tstate);
16957 if (PyErr_Occurred()) SWIG_fail;
16958 }
16959 {
16960 resultobj = SWIG_From_int((int)(result));
16961 }
16962 return resultobj;
16963 fail:
16964 return NULL;
16965 }
16966
16967
16968 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16969 PyObject *resultobj;
16970 wxDC *arg1 = (wxDC *) 0 ;
16971 int *arg2 = (int *) 0 ;
16972 int *arg3 = (int *) 0 ;
16973 int *arg4 = (int *) 0 ;
16974 int *arg5 = (int *) 0 ;
16975 int temp2 ;
16976 int res2 = 0 ;
16977 int temp3 ;
16978 int res3 = 0 ;
16979 int temp4 ;
16980 int res4 = 0 ;
16981 int temp5 ;
16982 int res5 = 0 ;
16983 PyObject * obj0 = 0 ;
16984 char *kwnames[] = {
16985 (char *) "self", NULL
16986 };
16987
16988 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16989 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16990 arg4 = &temp4; res4 = SWIG_NEWOBJ;
16991 arg5 = &temp5; res5 = SWIG_NEWOBJ;
16992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
16993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16994 if (SWIG_arg_fail(1)) SWIG_fail;
16995 {
16996 PyThreadState* __tstate = wxPyBeginAllowThreads();
16997 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
16998
16999 wxPyEndAllowThreads(__tstate);
17000 if (PyErr_Occurred()) SWIG_fail;
17001 }
17002 Py_INCREF(Py_None); resultobj = Py_None;
17003 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17004 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17005 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17006 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17007 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
17008 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
17009 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
17010 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
17011 return resultobj;
17012 fail:
17013 return NULL;
17014 }
17015
17016
17017 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
17018 PyObject *resultobj;
17019 wxDC *arg1 = (wxDC *) 0 ;
17020 PyObject *arg2 = (PyObject *) 0 ;
17021 PyObject *arg3 = (PyObject *) 0 ;
17022 PyObject *arg4 = (PyObject *) 0 ;
17023 PyObject *result;
17024 PyObject * obj0 = 0 ;
17025 PyObject * obj1 = 0 ;
17026 PyObject * obj2 = 0 ;
17027 PyObject * obj3 = 0 ;
17028 char *kwnames[] = {
17029 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17030 };
17031
17032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17034 if (SWIG_arg_fail(1)) SWIG_fail;
17035 arg2 = obj1;
17036 arg3 = obj2;
17037 arg4 = obj3;
17038 {
17039 PyThreadState* __tstate = wxPyBeginAllowThreads();
17040 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
17041
17042 wxPyEndAllowThreads(__tstate);
17043 if (PyErr_Occurred()) SWIG_fail;
17044 }
17045 resultobj = result;
17046 return resultobj;
17047 fail:
17048 return NULL;
17049 }
17050
17051
17052 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
17053 PyObject *resultobj;
17054 wxDC *arg1 = (wxDC *) 0 ;
17055 PyObject *arg2 = (PyObject *) 0 ;
17056 PyObject *arg3 = (PyObject *) 0 ;
17057 PyObject *arg4 = (PyObject *) 0 ;
17058 PyObject *result;
17059 PyObject * obj0 = 0 ;
17060 PyObject * obj1 = 0 ;
17061 PyObject * obj2 = 0 ;
17062 PyObject * obj3 = 0 ;
17063 char *kwnames[] = {
17064 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17065 };
17066
17067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17069 if (SWIG_arg_fail(1)) SWIG_fail;
17070 arg2 = obj1;
17071 arg3 = obj2;
17072 arg4 = obj3;
17073 {
17074 PyThreadState* __tstate = wxPyBeginAllowThreads();
17075 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
17076
17077 wxPyEndAllowThreads(__tstate);
17078 if (PyErr_Occurred()) SWIG_fail;
17079 }
17080 resultobj = result;
17081 return resultobj;
17082 fail:
17083 return NULL;
17084 }
17085
17086
17087 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
17088 PyObject *resultobj;
17089 wxDC *arg1 = (wxDC *) 0 ;
17090 PyObject *arg2 = (PyObject *) 0 ;
17091 PyObject *arg3 = (PyObject *) 0 ;
17092 PyObject *arg4 = (PyObject *) 0 ;
17093 PyObject *result;
17094 PyObject * obj0 = 0 ;
17095 PyObject * obj1 = 0 ;
17096 PyObject * obj2 = 0 ;
17097 PyObject * obj3 = 0 ;
17098 char *kwnames[] = {
17099 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17100 };
17101
17102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17104 if (SWIG_arg_fail(1)) SWIG_fail;
17105 arg2 = obj1;
17106 arg3 = obj2;
17107 arg4 = obj3;
17108 {
17109 PyThreadState* __tstate = wxPyBeginAllowThreads();
17110 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17111
17112 wxPyEndAllowThreads(__tstate);
17113 if (PyErr_Occurred()) SWIG_fail;
17114 }
17115 resultobj = result;
17116 return resultobj;
17117 fail:
17118 return NULL;
17119 }
17120
17121
17122 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17123 PyObject *resultobj;
17124 wxDC *arg1 = (wxDC *) 0 ;
17125 PyObject *arg2 = (PyObject *) 0 ;
17126 PyObject *arg3 = (PyObject *) 0 ;
17127 PyObject *arg4 = (PyObject *) 0 ;
17128 PyObject *result;
17129 PyObject * obj0 = 0 ;
17130 PyObject * obj1 = 0 ;
17131 PyObject * obj2 = 0 ;
17132 PyObject * obj3 = 0 ;
17133 char *kwnames[] = {
17134 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17135 };
17136
17137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17139 if (SWIG_arg_fail(1)) SWIG_fail;
17140 arg2 = obj1;
17141 arg3 = obj2;
17142 arg4 = obj3;
17143 {
17144 PyThreadState* __tstate = wxPyBeginAllowThreads();
17145 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17146
17147 wxPyEndAllowThreads(__tstate);
17148 if (PyErr_Occurred()) SWIG_fail;
17149 }
17150 resultobj = result;
17151 return resultobj;
17152 fail:
17153 return NULL;
17154 }
17155
17156
17157 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17158 PyObject *resultobj;
17159 wxDC *arg1 = (wxDC *) 0 ;
17160 PyObject *arg2 = (PyObject *) 0 ;
17161 PyObject *arg3 = (PyObject *) 0 ;
17162 PyObject *arg4 = (PyObject *) 0 ;
17163 PyObject *result;
17164 PyObject * obj0 = 0 ;
17165 PyObject * obj1 = 0 ;
17166 PyObject * obj2 = 0 ;
17167 PyObject * obj3 = 0 ;
17168 char *kwnames[] = {
17169 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17170 };
17171
17172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17174 if (SWIG_arg_fail(1)) SWIG_fail;
17175 arg2 = obj1;
17176 arg3 = obj2;
17177 arg4 = obj3;
17178 {
17179 PyThreadState* __tstate = wxPyBeginAllowThreads();
17180 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17181
17182 wxPyEndAllowThreads(__tstate);
17183 if (PyErr_Occurred()) SWIG_fail;
17184 }
17185 resultobj = result;
17186 return resultobj;
17187 fail:
17188 return NULL;
17189 }
17190
17191
17192 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17193 PyObject *resultobj;
17194 wxDC *arg1 = (wxDC *) 0 ;
17195 PyObject *arg2 = (PyObject *) 0 ;
17196 PyObject *arg3 = (PyObject *) 0 ;
17197 PyObject *arg4 = (PyObject *) 0 ;
17198 PyObject *arg5 = (PyObject *) 0 ;
17199 PyObject *result;
17200 PyObject * obj0 = 0 ;
17201 PyObject * obj1 = 0 ;
17202 PyObject * obj2 = 0 ;
17203 PyObject * obj3 = 0 ;
17204 PyObject * obj4 = 0 ;
17205 char *kwnames[] = {
17206 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17207 };
17208
17209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17211 if (SWIG_arg_fail(1)) SWIG_fail;
17212 arg2 = obj1;
17213 arg3 = obj2;
17214 arg4 = obj3;
17215 arg5 = obj4;
17216 {
17217 PyThreadState* __tstate = wxPyBeginAllowThreads();
17218 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17219
17220 wxPyEndAllowThreads(__tstate);
17221 if (PyErr_Occurred()) SWIG_fail;
17222 }
17223 resultobj = result;
17224 return resultobj;
17225 fail:
17226 return NULL;
17227 }
17228
17229
17230 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17231 PyObject *obj;
17232 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17233 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17234 Py_INCREF(obj);
17235 return Py_BuildValue((char *)"");
17236 }
17237 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17238 PyObject *resultobj;
17239 wxMemoryDC *result;
17240 char *kwnames[] = {
17241 NULL
17242 };
17243
17244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17245 {
17246 if (!wxPyCheckForApp()) SWIG_fail;
17247 PyThreadState* __tstate = wxPyBeginAllowThreads();
17248 result = (wxMemoryDC *)new wxMemoryDC();
17249
17250 wxPyEndAllowThreads(__tstate);
17251 if (PyErr_Occurred()) SWIG_fail;
17252 }
17253 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17254 return resultobj;
17255 fail:
17256 return NULL;
17257 }
17258
17259
17260 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17261 PyObject *resultobj;
17262 wxDC *arg1 = (wxDC *) 0 ;
17263 wxMemoryDC *result;
17264 PyObject * obj0 = 0 ;
17265 char *kwnames[] = {
17266 (char *) "oldDC", NULL
17267 };
17268
17269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17271 if (SWIG_arg_fail(1)) SWIG_fail;
17272 {
17273 if (!wxPyCheckForApp()) SWIG_fail;
17274 PyThreadState* __tstate = wxPyBeginAllowThreads();
17275 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17276
17277 wxPyEndAllowThreads(__tstate);
17278 if (PyErr_Occurred()) SWIG_fail;
17279 }
17280 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17281 return resultobj;
17282 fail:
17283 return NULL;
17284 }
17285
17286
17287 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17288 PyObject *resultobj;
17289 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17290 wxBitmap *arg2 = 0 ;
17291 PyObject * obj0 = 0 ;
17292 PyObject * obj1 = 0 ;
17293 char *kwnames[] = {
17294 (char *) "self",(char *) "bitmap", NULL
17295 };
17296
17297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17299 if (SWIG_arg_fail(1)) SWIG_fail;
17300 {
17301 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17302 if (SWIG_arg_fail(2)) SWIG_fail;
17303 if (arg2 == NULL) {
17304 SWIG_null_ref("wxBitmap");
17305 }
17306 if (SWIG_arg_fail(2)) SWIG_fail;
17307 }
17308 {
17309 PyThreadState* __tstate = wxPyBeginAllowThreads();
17310 (arg1)->SelectObject((wxBitmap const &)*arg2);
17311
17312 wxPyEndAllowThreads(__tstate);
17313 if (PyErr_Occurred()) SWIG_fail;
17314 }
17315 Py_INCREF(Py_None); resultobj = Py_None;
17316 return resultobj;
17317 fail:
17318 return NULL;
17319 }
17320
17321
17322 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17323 PyObject *obj;
17324 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17325 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17326 Py_INCREF(obj);
17327 return Py_BuildValue((char *)"");
17328 }
17329 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17330 PyObject *resultobj;
17331 wxDC *arg1 = (wxDC *) 0 ;
17332 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17333 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17334 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17335 wxBufferedDC *result;
17336 PyObject * obj0 = 0 ;
17337 PyObject * obj1 = 0 ;
17338 PyObject * obj2 = 0 ;
17339
17340 if(!PyArg_ParseTuple(args,(char *)"O|OO:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17342 if (SWIG_arg_fail(1)) SWIG_fail;
17343 if (obj1) {
17344 {
17345 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17346 if (SWIG_arg_fail(2)) SWIG_fail;
17347 if (arg2 == NULL) {
17348 SWIG_null_ref("wxBitmap");
17349 }
17350 if (SWIG_arg_fail(2)) SWIG_fail;
17351 }
17352 }
17353 if (obj2) {
17354 {
17355 arg3 = (int)(SWIG_As_int(obj2));
17356 if (SWIG_arg_fail(3)) SWIG_fail;
17357 }
17358 }
17359 {
17360 if (!wxPyCheckForApp()) SWIG_fail;
17361 PyThreadState* __tstate = wxPyBeginAllowThreads();
17362 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
17363
17364 wxPyEndAllowThreads(__tstate);
17365 if (PyErr_Occurred()) SWIG_fail;
17366 }
17367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17368 return resultobj;
17369 fail:
17370 return NULL;
17371 }
17372
17373
17374 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17375 PyObject *resultobj;
17376 wxDC *arg1 = (wxDC *) 0 ;
17377 wxSize *arg2 = 0 ;
17378 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17379 wxBufferedDC *result;
17380 wxSize temp2 ;
17381 PyObject * obj0 = 0 ;
17382 PyObject * obj1 = 0 ;
17383 PyObject * obj2 = 0 ;
17384
17385 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17387 if (SWIG_arg_fail(1)) SWIG_fail;
17388 {
17389 arg2 = &temp2;
17390 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17391 }
17392 if (obj2) {
17393 {
17394 arg3 = (int)(SWIG_As_int(obj2));
17395 if (SWIG_arg_fail(3)) SWIG_fail;
17396 }
17397 }
17398 {
17399 if (!wxPyCheckForApp()) SWIG_fail;
17400 PyThreadState* __tstate = wxPyBeginAllowThreads();
17401 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
17402
17403 wxPyEndAllowThreads(__tstate);
17404 if (PyErr_Occurred()) SWIG_fail;
17405 }
17406 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17407 return resultobj;
17408 fail:
17409 return NULL;
17410 }
17411
17412
17413 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
17414 int argc;
17415 PyObject *argv[4];
17416 int ii;
17417
17418 argc = PyObject_Length(args);
17419 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
17420 argv[ii] = PyTuple_GetItem(args,ii);
17421 }
17422 if ((argc >= 1) && (argc <= 3)) {
17423 int _v;
17424 {
17425 void *ptr;
17426 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17427 _v = 0;
17428 PyErr_Clear();
17429 } else {
17430 _v = 1;
17431 }
17432 }
17433 if (_v) {
17434 if (argc <= 1) {
17435 return _wrap_new_BufferedDC__SWIG_0(self,args);
17436 }
17437 {
17438 void *ptr = 0;
17439 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
17440 _v = 0;
17441 PyErr_Clear();
17442 } else {
17443 _v = (ptr != 0);
17444 }
17445 }
17446 if (_v) {
17447 if (argc <= 2) {
17448 return _wrap_new_BufferedDC__SWIG_0(self,args);
17449 }
17450 _v = SWIG_Check_int(argv[2]);
17451 if (_v) {
17452 return _wrap_new_BufferedDC__SWIG_0(self,args);
17453 }
17454 }
17455 }
17456 }
17457 if ((argc >= 2) && (argc <= 3)) {
17458 int _v;
17459 {
17460 void *ptr;
17461 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17462 _v = 0;
17463 PyErr_Clear();
17464 } else {
17465 _v = 1;
17466 }
17467 }
17468 if (_v) {
17469 {
17470 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
17471 }
17472 if (_v) {
17473 if (argc <= 2) {
17474 return _wrap_new_BufferedDC__SWIG_1(self,args);
17475 }
17476 _v = SWIG_Check_int(argv[2]);
17477 if (_v) {
17478 return _wrap_new_BufferedDC__SWIG_1(self,args);
17479 }
17480 }
17481 }
17482 }
17483
17484 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
17485 return NULL;
17486 }
17487
17488
17489 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
17490 PyObject *resultobj;
17491 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17492 PyObject * obj0 = 0 ;
17493 char *kwnames[] = {
17494 (char *) "self", NULL
17495 };
17496
17497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
17498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17499 if (SWIG_arg_fail(1)) SWIG_fail;
17500 {
17501 PyThreadState* __tstate = wxPyBeginAllowThreads();
17502 delete arg1;
17503
17504 wxPyEndAllowThreads(__tstate);
17505 if (PyErr_Occurred()) SWIG_fail;
17506 }
17507 Py_INCREF(Py_None); resultobj = Py_None;
17508 return resultobj;
17509 fail:
17510 return NULL;
17511 }
17512
17513
17514 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
17515 PyObject *resultobj;
17516 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17517 PyObject * obj0 = 0 ;
17518 char *kwnames[] = {
17519 (char *) "self", NULL
17520 };
17521
17522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
17523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17524 if (SWIG_arg_fail(1)) SWIG_fail;
17525 {
17526 PyThreadState* __tstate = wxPyBeginAllowThreads();
17527 (arg1)->UnMask();
17528
17529 wxPyEndAllowThreads(__tstate);
17530 if (PyErr_Occurred()) SWIG_fail;
17531 }
17532 Py_INCREF(Py_None); resultobj = Py_None;
17533 return resultobj;
17534 fail:
17535 return NULL;
17536 }
17537
17538
17539 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
17540 PyObject *obj;
17541 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17542 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
17543 Py_INCREF(obj);
17544 return Py_BuildValue((char *)"");
17545 }
17546 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17547 PyObject *resultobj;
17548 wxWindow *arg1 = (wxWindow *) 0 ;
17549 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17550 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17551 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17552 wxBufferedPaintDC *result;
17553 PyObject * obj0 = 0 ;
17554 PyObject * obj1 = 0 ;
17555 PyObject * obj2 = 0 ;
17556 char *kwnames[] = {
17557 (char *) "window",(char *) "buffer",(char *) "style", NULL
17558 };
17559
17560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
17561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17562 if (SWIG_arg_fail(1)) SWIG_fail;
17563 if (obj1) {
17564 {
17565 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17566 if (SWIG_arg_fail(2)) SWIG_fail;
17567 if (arg2 == NULL) {
17568 SWIG_null_ref("wxBitmap");
17569 }
17570 if (SWIG_arg_fail(2)) SWIG_fail;
17571 }
17572 }
17573 if (obj2) {
17574 {
17575 arg3 = (int)(SWIG_As_int(obj2));
17576 if (SWIG_arg_fail(3)) SWIG_fail;
17577 }
17578 }
17579 {
17580 if (!wxPyCheckForApp()) SWIG_fail;
17581 PyThreadState* __tstate = wxPyBeginAllowThreads();
17582 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
17583
17584 wxPyEndAllowThreads(__tstate);
17585 if (PyErr_Occurred()) SWIG_fail;
17586 }
17587 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
17588 return resultobj;
17589 fail:
17590 return NULL;
17591 }
17592
17593
17594 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
17595 PyObject *obj;
17596 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17597 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
17598 Py_INCREF(obj);
17599 return Py_BuildValue((char *)"");
17600 }
17601 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
17602 PyObject *resultobj;
17603 wxScreenDC *result;
17604 char *kwnames[] = {
17605 NULL
17606 };
17607
17608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
17609 {
17610 if (!wxPyCheckForApp()) SWIG_fail;
17611 PyThreadState* __tstate = wxPyBeginAllowThreads();
17612 result = (wxScreenDC *)new wxScreenDC();
17613
17614 wxPyEndAllowThreads(__tstate);
17615 if (PyErr_Occurred()) SWIG_fail;
17616 }
17617 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
17618 return resultobj;
17619 fail:
17620 return NULL;
17621 }
17622
17623
17624 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
17625 PyObject *resultobj;
17626 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17627 wxWindow *arg2 = (wxWindow *) 0 ;
17628 bool result;
17629 PyObject * obj0 = 0 ;
17630 PyObject * obj1 = 0 ;
17631 char *kwnames[] = {
17632 (char *) "self",(char *) "window", NULL
17633 };
17634
17635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
17636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17637 if (SWIG_arg_fail(1)) SWIG_fail;
17638 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17639 if (SWIG_arg_fail(2)) SWIG_fail;
17640 {
17641 PyThreadState* __tstate = wxPyBeginAllowThreads();
17642 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17643
17644 wxPyEndAllowThreads(__tstate);
17645 if (PyErr_Occurred()) SWIG_fail;
17646 }
17647 {
17648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17649 }
17650 return resultobj;
17651 fail:
17652 return NULL;
17653 }
17654
17655
17656 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17657 PyObject *resultobj;
17658 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17659 wxRect *arg2 = (wxRect *) NULL ;
17660 bool result;
17661 PyObject * obj0 = 0 ;
17662 PyObject * obj1 = 0 ;
17663 char *kwnames[] = {
17664 (char *) "self",(char *) "rect", NULL
17665 };
17666
17667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
17668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17669 if (SWIG_arg_fail(1)) SWIG_fail;
17670 if (obj1) {
17671 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
17672 if (SWIG_arg_fail(2)) SWIG_fail;
17673 }
17674 {
17675 PyThreadState* __tstate = wxPyBeginAllowThreads();
17676 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17677
17678 wxPyEndAllowThreads(__tstate);
17679 if (PyErr_Occurred()) SWIG_fail;
17680 }
17681 {
17682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17683 }
17684 return resultobj;
17685 fail:
17686 return NULL;
17687 }
17688
17689
17690 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17691 PyObject *resultobj;
17692 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17693 bool result;
17694 PyObject * obj0 = 0 ;
17695 char *kwnames[] = {
17696 (char *) "self", NULL
17697 };
17698
17699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
17700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17701 if (SWIG_arg_fail(1)) SWIG_fail;
17702 {
17703 PyThreadState* __tstate = wxPyBeginAllowThreads();
17704 result = (bool)(arg1)->EndDrawingOnTop();
17705
17706 wxPyEndAllowThreads(__tstate);
17707 if (PyErr_Occurred()) SWIG_fail;
17708 }
17709 {
17710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17711 }
17712 return resultobj;
17713 fail:
17714 return NULL;
17715 }
17716
17717
17718 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
17719 PyObject *obj;
17720 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17721 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
17722 Py_INCREF(obj);
17723 return Py_BuildValue((char *)"");
17724 }
17725 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
17726 PyObject *resultobj;
17727 wxWindow *arg1 = (wxWindow *) 0 ;
17728 wxClientDC *result;
17729 PyObject * obj0 = 0 ;
17730 char *kwnames[] = {
17731 (char *) "win", NULL
17732 };
17733
17734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
17735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17736 if (SWIG_arg_fail(1)) SWIG_fail;
17737 {
17738 if (!wxPyCheckForApp()) SWIG_fail;
17739 PyThreadState* __tstate = wxPyBeginAllowThreads();
17740 result = (wxClientDC *)new wxClientDC(arg1);
17741
17742 wxPyEndAllowThreads(__tstate);
17743 if (PyErr_Occurred()) SWIG_fail;
17744 }
17745 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
17746 return resultobj;
17747 fail:
17748 return NULL;
17749 }
17750
17751
17752 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
17753 PyObject *obj;
17754 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17755 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
17756 Py_INCREF(obj);
17757 return Py_BuildValue((char *)"");
17758 }
17759 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17760 PyObject *resultobj;
17761 wxWindow *arg1 = (wxWindow *) 0 ;
17762 wxPaintDC *result;
17763 PyObject * obj0 = 0 ;
17764 char *kwnames[] = {
17765 (char *) "win", NULL
17766 };
17767
17768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
17769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17770 if (SWIG_arg_fail(1)) SWIG_fail;
17771 {
17772 if (!wxPyCheckForApp()) SWIG_fail;
17773 PyThreadState* __tstate = wxPyBeginAllowThreads();
17774 result = (wxPaintDC *)new wxPaintDC(arg1);
17775
17776 wxPyEndAllowThreads(__tstate);
17777 if (PyErr_Occurred()) SWIG_fail;
17778 }
17779 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
17780 return resultobj;
17781 fail:
17782 return NULL;
17783 }
17784
17785
17786 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
17787 PyObject *obj;
17788 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17789 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
17790 Py_INCREF(obj);
17791 return Py_BuildValue((char *)"");
17792 }
17793 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
17794 PyObject *resultobj;
17795 wxWindow *arg1 = (wxWindow *) 0 ;
17796 wxWindowDC *result;
17797 PyObject * obj0 = 0 ;
17798 char *kwnames[] = {
17799 (char *) "win", NULL
17800 };
17801
17802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
17803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17804 if (SWIG_arg_fail(1)) SWIG_fail;
17805 {
17806 if (!wxPyCheckForApp()) SWIG_fail;
17807 PyThreadState* __tstate = wxPyBeginAllowThreads();
17808 result = (wxWindowDC *)new wxWindowDC(arg1);
17809
17810 wxPyEndAllowThreads(__tstate);
17811 if (PyErr_Occurred()) SWIG_fail;
17812 }
17813 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
17814 return resultobj;
17815 fail:
17816 return NULL;
17817 }
17818
17819
17820 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
17821 PyObject *obj;
17822 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17823 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
17824 Py_INCREF(obj);
17825 return Py_BuildValue((char *)"");
17826 }
17827 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
17828 PyObject *resultobj;
17829 wxDC *arg1 = 0 ;
17830 bool arg2 ;
17831 wxMirrorDC *result;
17832 PyObject * obj0 = 0 ;
17833 PyObject * obj1 = 0 ;
17834 char *kwnames[] = {
17835 (char *) "dc",(char *) "mirror", NULL
17836 };
17837
17838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
17839 {
17840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17841 if (SWIG_arg_fail(1)) SWIG_fail;
17842 if (arg1 == NULL) {
17843 SWIG_null_ref("wxDC");
17844 }
17845 if (SWIG_arg_fail(1)) SWIG_fail;
17846 }
17847 {
17848 arg2 = (bool)(SWIG_As_bool(obj1));
17849 if (SWIG_arg_fail(2)) SWIG_fail;
17850 }
17851 {
17852 if (!wxPyCheckForApp()) SWIG_fail;
17853 PyThreadState* __tstate = wxPyBeginAllowThreads();
17854 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
17855
17856 wxPyEndAllowThreads(__tstate);
17857 if (PyErr_Occurred()) SWIG_fail;
17858 }
17859 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
17860 return resultobj;
17861 fail:
17862 return NULL;
17863 }
17864
17865
17866 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
17867 PyObject *obj;
17868 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17869 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
17870 Py_INCREF(obj);
17871 return Py_BuildValue((char *)"");
17872 }
17873 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
17874 PyObject *resultobj;
17875 wxPrintData *arg1 = 0 ;
17876 wxPostScriptDC *result;
17877 PyObject * obj0 = 0 ;
17878 char *kwnames[] = {
17879 (char *) "printData", NULL
17880 };
17881
17882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
17883 {
17884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17885 if (SWIG_arg_fail(1)) SWIG_fail;
17886 if (arg1 == NULL) {
17887 SWIG_null_ref("wxPrintData");
17888 }
17889 if (SWIG_arg_fail(1)) SWIG_fail;
17890 }
17891 {
17892 if (!wxPyCheckForApp()) SWIG_fail;
17893 PyThreadState* __tstate = wxPyBeginAllowThreads();
17894 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
17895
17896 wxPyEndAllowThreads(__tstate);
17897 if (PyErr_Occurred()) SWIG_fail;
17898 }
17899 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
17900 return resultobj;
17901 fail:
17902 return NULL;
17903 }
17904
17905
17906 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17907 PyObject *resultobj;
17908 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17909 wxPrintData *result;
17910 PyObject * obj0 = 0 ;
17911 char *kwnames[] = {
17912 (char *) "self", NULL
17913 };
17914
17915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
17916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17917 if (SWIG_arg_fail(1)) SWIG_fail;
17918 {
17919 PyThreadState* __tstate = wxPyBeginAllowThreads();
17920 {
17921 wxPrintData &_result_ref = (arg1)->GetPrintData();
17922 result = (wxPrintData *) &_result_ref;
17923 }
17924
17925 wxPyEndAllowThreads(__tstate);
17926 if (PyErr_Occurred()) SWIG_fail;
17927 }
17928 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
17929 return resultobj;
17930 fail:
17931 return NULL;
17932 }
17933
17934
17935 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17936 PyObject *resultobj;
17937 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17938 wxPrintData *arg2 = 0 ;
17939 PyObject * obj0 = 0 ;
17940 PyObject * obj1 = 0 ;
17941 char *kwnames[] = {
17942 (char *) "self",(char *) "data", NULL
17943 };
17944
17945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
17946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17947 if (SWIG_arg_fail(1)) SWIG_fail;
17948 {
17949 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17950 if (SWIG_arg_fail(2)) SWIG_fail;
17951 if (arg2 == NULL) {
17952 SWIG_null_ref("wxPrintData");
17953 }
17954 if (SWIG_arg_fail(2)) SWIG_fail;
17955 }
17956 {
17957 PyThreadState* __tstate = wxPyBeginAllowThreads();
17958 (arg1)->SetPrintData((wxPrintData const &)*arg2);
17959
17960 wxPyEndAllowThreads(__tstate);
17961 if (PyErr_Occurred()) SWIG_fail;
17962 }
17963 Py_INCREF(Py_None); resultobj = Py_None;
17964 return resultobj;
17965 fail:
17966 return NULL;
17967 }
17968
17969
17970 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17971 PyObject *resultobj;
17972 int arg1 ;
17973 PyObject * obj0 = 0 ;
17974 char *kwnames[] = {
17975 (char *) "ppi", NULL
17976 };
17977
17978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
17979 {
17980 arg1 = (int)(SWIG_As_int(obj0));
17981 if (SWIG_arg_fail(1)) SWIG_fail;
17982 }
17983 {
17984 PyThreadState* __tstate = wxPyBeginAllowThreads();
17985 wxPostScriptDC::SetResolution(arg1);
17986
17987 wxPyEndAllowThreads(__tstate);
17988 if (PyErr_Occurred()) SWIG_fail;
17989 }
17990 Py_INCREF(Py_None); resultobj = Py_None;
17991 return resultobj;
17992 fail:
17993 return NULL;
17994 }
17995
17996
17997 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17998 PyObject *resultobj;
17999 int result;
18000 char *kwnames[] = {
18001 NULL
18002 };
18003
18004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
18005 {
18006 PyThreadState* __tstate = wxPyBeginAllowThreads();
18007 result = (int)wxPostScriptDC::GetResolution();
18008
18009 wxPyEndAllowThreads(__tstate);
18010 if (PyErr_Occurred()) SWIG_fail;
18011 }
18012 {
18013 resultobj = SWIG_From_int((int)(result));
18014 }
18015 return resultobj;
18016 fail:
18017 return NULL;
18018 }
18019
18020
18021 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
18022 PyObject *obj;
18023 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18024 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
18025 Py_INCREF(obj);
18026 return Py_BuildValue((char *)"");
18027 }
18028 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18029 PyObject *resultobj;
18030 wxString const &arg1_defvalue = wxPyEmptyString ;
18031 wxString *arg1 = (wxString *) &arg1_defvalue ;
18032 wxMetaFile *result;
18033 bool temp1 = false ;
18034 PyObject * obj0 = 0 ;
18035 char *kwnames[] = {
18036 (char *) "filename", NULL
18037 };
18038
18039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
18040 if (obj0) {
18041 {
18042 arg1 = wxString_in_helper(obj0);
18043 if (arg1 == NULL) SWIG_fail;
18044 temp1 = true;
18045 }
18046 }
18047 {
18048 if (!wxPyCheckForApp()) SWIG_fail;
18049 PyThreadState* __tstate = wxPyBeginAllowThreads();
18050 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
18051
18052 wxPyEndAllowThreads(__tstate);
18053 if (PyErr_Occurred()) SWIG_fail;
18054 }
18055 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
18056 {
18057 if (temp1)
18058 delete arg1;
18059 }
18060 return resultobj;
18061 fail:
18062 {
18063 if (temp1)
18064 delete arg1;
18065 }
18066 return NULL;
18067 }
18068
18069
18070 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
18071 PyObject *obj;
18072 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18073 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
18074 Py_INCREF(obj);
18075 return Py_BuildValue((char *)"");
18076 }
18077 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
18078 PyObject *resultobj;
18079 wxString const &arg1_defvalue = wxPyEmptyString ;
18080 wxString *arg1 = (wxString *) &arg1_defvalue ;
18081 int arg2 = (int) 0 ;
18082 int arg3 = (int) 0 ;
18083 wxString const &arg4_defvalue = wxPyEmptyString ;
18084 wxString *arg4 = (wxString *) &arg4_defvalue ;
18085 wxMetaFileDC *result;
18086 bool temp1 = false ;
18087 bool temp4 = false ;
18088 PyObject * obj0 = 0 ;
18089 PyObject * obj1 = 0 ;
18090 PyObject * obj2 = 0 ;
18091 PyObject * obj3 = 0 ;
18092 char *kwnames[] = {
18093 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
18094 };
18095
18096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18097 if (obj0) {
18098 {
18099 arg1 = wxString_in_helper(obj0);
18100 if (arg1 == NULL) SWIG_fail;
18101 temp1 = true;
18102 }
18103 }
18104 if (obj1) {
18105 {
18106 arg2 = (int)(SWIG_As_int(obj1));
18107 if (SWIG_arg_fail(2)) SWIG_fail;
18108 }
18109 }
18110 if (obj2) {
18111 {
18112 arg3 = (int)(SWIG_As_int(obj2));
18113 if (SWIG_arg_fail(3)) SWIG_fail;
18114 }
18115 }
18116 if (obj3) {
18117 {
18118 arg4 = wxString_in_helper(obj3);
18119 if (arg4 == NULL) SWIG_fail;
18120 temp4 = true;
18121 }
18122 }
18123 {
18124 if (!wxPyCheckForApp()) SWIG_fail;
18125 PyThreadState* __tstate = wxPyBeginAllowThreads();
18126 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
18127
18128 wxPyEndAllowThreads(__tstate);
18129 if (PyErr_Occurred()) SWIG_fail;
18130 }
18131 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
18132 {
18133 if (temp1)
18134 delete arg1;
18135 }
18136 {
18137 if (temp4)
18138 delete arg4;
18139 }
18140 return resultobj;
18141 fail:
18142 {
18143 if (temp1)
18144 delete arg1;
18145 }
18146 {
18147 if (temp4)
18148 delete arg4;
18149 }
18150 return NULL;
18151 }
18152
18153
18154 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
18155 PyObject *obj;
18156 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18157 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
18158 Py_INCREF(obj);
18159 return Py_BuildValue((char *)"");
18160 }
18161 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
18162 PyObject *resultobj;
18163 wxPrintData *arg1 = 0 ;
18164 wxPrinterDC *result;
18165 PyObject * obj0 = 0 ;
18166 char *kwnames[] = {
18167 (char *) "printData", NULL
18168 };
18169
18170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
18171 {
18172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18173 if (SWIG_arg_fail(1)) SWIG_fail;
18174 if (arg1 == NULL) {
18175 SWIG_null_ref("wxPrintData");
18176 }
18177 if (SWIG_arg_fail(1)) SWIG_fail;
18178 }
18179 {
18180 if (!wxPyCheckForApp()) SWIG_fail;
18181 PyThreadState* __tstate = wxPyBeginAllowThreads();
18182 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
18183
18184 wxPyEndAllowThreads(__tstate);
18185 if (PyErr_Occurred()) SWIG_fail;
18186 }
18187 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
18188 return resultobj;
18189 fail:
18190 return NULL;
18191 }
18192
18193
18194 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
18195 PyObject *obj;
18196 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18197 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
18198 Py_INCREF(obj);
18199 return Py_BuildValue((char *)"");
18200 }
18201 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18202 PyObject *resultobj;
18203 int arg1 ;
18204 int arg2 ;
18205 int arg3 = (int) true ;
18206 int arg4 = (int) 1 ;
18207 wxImageList *result;
18208 PyObject * obj0 = 0 ;
18209 PyObject * obj1 = 0 ;
18210 PyObject * obj2 = 0 ;
18211 PyObject * obj3 = 0 ;
18212 char *kwnames[] = {
18213 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
18214 };
18215
18216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18217 {
18218 arg1 = (int)(SWIG_As_int(obj0));
18219 if (SWIG_arg_fail(1)) SWIG_fail;
18220 }
18221 {
18222 arg2 = (int)(SWIG_As_int(obj1));
18223 if (SWIG_arg_fail(2)) SWIG_fail;
18224 }
18225 if (obj2) {
18226 {
18227 arg3 = (int)(SWIG_As_int(obj2));
18228 if (SWIG_arg_fail(3)) SWIG_fail;
18229 }
18230 }
18231 if (obj3) {
18232 {
18233 arg4 = (int)(SWIG_As_int(obj3));
18234 if (SWIG_arg_fail(4)) SWIG_fail;
18235 }
18236 }
18237 {
18238 if (!wxPyCheckForApp()) SWIG_fail;
18239 PyThreadState* __tstate = wxPyBeginAllowThreads();
18240 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
18241
18242 wxPyEndAllowThreads(__tstate);
18243 if (PyErr_Occurred()) SWIG_fail;
18244 }
18245 {
18246 resultobj = wxPyMake_wxObject(result, 1);
18247 }
18248 return resultobj;
18249 fail:
18250 return NULL;
18251 }
18252
18253
18254 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18255 PyObject *resultobj;
18256 wxImageList *arg1 = (wxImageList *) 0 ;
18257 PyObject * obj0 = 0 ;
18258 char *kwnames[] = {
18259 (char *) "self", NULL
18260 };
18261
18262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
18263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18264 if (SWIG_arg_fail(1)) SWIG_fail;
18265 {
18266 PyThreadState* __tstate = wxPyBeginAllowThreads();
18267 delete arg1;
18268
18269 wxPyEndAllowThreads(__tstate);
18270 if (PyErr_Occurred()) SWIG_fail;
18271 }
18272 Py_INCREF(Py_None); resultobj = Py_None;
18273 return resultobj;
18274 fail:
18275 return NULL;
18276 }
18277
18278
18279 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
18280 PyObject *resultobj;
18281 wxImageList *arg1 = (wxImageList *) 0 ;
18282 wxBitmap *arg2 = 0 ;
18283 wxBitmap const &arg3_defvalue = wxNullBitmap ;
18284 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
18285 int result;
18286 PyObject * obj0 = 0 ;
18287 PyObject * obj1 = 0 ;
18288 PyObject * obj2 = 0 ;
18289 char *kwnames[] = {
18290 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
18291 };
18292
18293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
18294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18295 if (SWIG_arg_fail(1)) SWIG_fail;
18296 {
18297 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18298 if (SWIG_arg_fail(2)) SWIG_fail;
18299 if (arg2 == NULL) {
18300 SWIG_null_ref("wxBitmap");
18301 }
18302 if (SWIG_arg_fail(2)) SWIG_fail;
18303 }
18304 if (obj2) {
18305 {
18306 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18307 if (SWIG_arg_fail(3)) SWIG_fail;
18308 if (arg3 == NULL) {
18309 SWIG_null_ref("wxBitmap");
18310 }
18311 if (SWIG_arg_fail(3)) SWIG_fail;
18312 }
18313 }
18314 {
18315 PyThreadState* __tstate = wxPyBeginAllowThreads();
18316 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
18317
18318 wxPyEndAllowThreads(__tstate);
18319 if (PyErr_Occurred()) SWIG_fail;
18320 }
18321 {
18322 resultobj = SWIG_From_int((int)(result));
18323 }
18324 return resultobj;
18325 fail:
18326 return NULL;
18327 }
18328
18329
18330 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
18331 PyObject *resultobj;
18332 wxImageList *arg1 = (wxImageList *) 0 ;
18333 wxBitmap *arg2 = 0 ;
18334 wxColour *arg3 = 0 ;
18335 int result;
18336 wxColour temp3 ;
18337 PyObject * obj0 = 0 ;
18338 PyObject * obj1 = 0 ;
18339 PyObject * obj2 = 0 ;
18340 char *kwnames[] = {
18341 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
18342 };
18343
18344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
18345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18346 if (SWIG_arg_fail(1)) SWIG_fail;
18347 {
18348 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18349 if (SWIG_arg_fail(2)) SWIG_fail;
18350 if (arg2 == NULL) {
18351 SWIG_null_ref("wxBitmap");
18352 }
18353 if (SWIG_arg_fail(2)) SWIG_fail;
18354 }
18355 {
18356 arg3 = &temp3;
18357 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
18358 }
18359 {
18360 PyThreadState* __tstate = wxPyBeginAllowThreads();
18361 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
18362
18363 wxPyEndAllowThreads(__tstate);
18364 if (PyErr_Occurred()) SWIG_fail;
18365 }
18366 {
18367 resultobj = SWIG_From_int((int)(result));
18368 }
18369 return resultobj;
18370 fail:
18371 return NULL;
18372 }
18373
18374
18375 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18376 PyObject *resultobj;
18377 wxImageList *arg1 = (wxImageList *) 0 ;
18378 wxIcon *arg2 = 0 ;
18379 int result;
18380 PyObject * obj0 = 0 ;
18381 PyObject * obj1 = 0 ;
18382 char *kwnames[] = {
18383 (char *) "self",(char *) "icon", NULL
18384 };
18385
18386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
18387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18388 if (SWIG_arg_fail(1)) SWIG_fail;
18389 {
18390 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
18391 if (SWIG_arg_fail(2)) SWIG_fail;
18392 if (arg2 == NULL) {
18393 SWIG_null_ref("wxIcon");
18394 }
18395 if (SWIG_arg_fail(2)) SWIG_fail;
18396 }
18397 {
18398 PyThreadState* __tstate = wxPyBeginAllowThreads();
18399 result = (int)(arg1)->Add((wxIcon const &)*arg2);
18400
18401 wxPyEndAllowThreads(__tstate);
18402 if (PyErr_Occurred()) SWIG_fail;
18403 }
18404 {
18405 resultobj = SWIG_From_int((int)(result));
18406 }
18407 return resultobj;
18408 fail:
18409 return NULL;
18410 }
18411
18412
18413 static PyObject *_wrap_ImageList_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
18414 PyObject *resultobj;
18415 wxImageList *arg1 = (wxImageList *) 0 ;
18416 int arg2 ;
18417 SwigValueWrapper<wxBitmap > result;
18418 PyObject * obj0 = 0 ;
18419 PyObject * obj1 = 0 ;
18420 char *kwnames[] = {
18421 (char *) "self",(char *) "index", NULL
18422 };
18423
18424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) goto fail;
18425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18426 if (SWIG_arg_fail(1)) SWIG_fail;
18427 {
18428 arg2 = (int)(SWIG_As_int(obj1));
18429 if (SWIG_arg_fail(2)) SWIG_fail;
18430 }
18431 {
18432 PyThreadState* __tstate = wxPyBeginAllowThreads();
18433 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
18434
18435 wxPyEndAllowThreads(__tstate);
18436 if (PyErr_Occurred()) SWIG_fail;
18437 }
18438 {
18439 wxBitmap * resultptr;
18440 resultptr = new wxBitmap((wxBitmap &)(result));
18441 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
18442 }
18443 return resultobj;
18444 fail:
18445 return NULL;
18446 }
18447
18448
18449 static PyObject *_wrap_ImageList_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18450 PyObject *resultobj;
18451 wxImageList *arg1 = (wxImageList *) 0 ;
18452 int arg2 ;
18453 wxIcon result;
18454 PyObject * obj0 = 0 ;
18455 PyObject * obj1 = 0 ;
18456 char *kwnames[] = {
18457 (char *) "self",(char *) "index", NULL
18458 };
18459
18460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) goto fail;
18461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18462 if (SWIG_arg_fail(1)) SWIG_fail;
18463 {
18464 arg2 = (int)(SWIG_As_int(obj1));
18465 if (SWIG_arg_fail(2)) SWIG_fail;
18466 }
18467 {
18468 PyThreadState* __tstate = wxPyBeginAllowThreads();
18469 result = ((wxImageList const *)arg1)->GetIcon(arg2);
18470
18471 wxPyEndAllowThreads(__tstate);
18472 if (PyErr_Occurred()) SWIG_fail;
18473 }
18474 {
18475 wxIcon * resultptr;
18476 resultptr = new wxIcon((wxIcon &)(result));
18477 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
18478 }
18479 return resultobj;
18480 fail:
18481 return NULL;
18482 }
18483
18484
18485 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
18486 PyObject *resultobj;
18487 wxImageList *arg1 = (wxImageList *) 0 ;
18488 int arg2 ;
18489 wxBitmap *arg3 = 0 ;
18490 bool result;
18491 PyObject * obj0 = 0 ;
18492 PyObject * obj1 = 0 ;
18493 PyObject * obj2 = 0 ;
18494 char *kwnames[] = {
18495 (char *) "self",(char *) "index",(char *) "bitmap", NULL
18496 };
18497
18498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_Replace",kwnames,&obj0,&obj1,&obj2)) goto fail;
18499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18500 if (SWIG_arg_fail(1)) SWIG_fail;
18501 {
18502 arg2 = (int)(SWIG_As_int(obj1));
18503 if (SWIG_arg_fail(2)) SWIG_fail;
18504 }
18505 {
18506 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18507 if (SWIG_arg_fail(3)) SWIG_fail;
18508 if (arg3 == NULL) {
18509 SWIG_null_ref("wxBitmap");
18510 }
18511 if (SWIG_arg_fail(3)) SWIG_fail;
18512 }
18513 {
18514 PyThreadState* __tstate = wxPyBeginAllowThreads();
18515 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3);
18516
18517 wxPyEndAllowThreads(__tstate);
18518 if (PyErr_Occurred()) SWIG_fail;
18519 }
18520 {
18521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18522 }
18523 return resultobj;
18524 fail:
18525 return NULL;
18526 }
18527
18528
18529 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
18530 PyObject *resultobj;
18531 wxImageList *arg1 = (wxImageList *) 0 ;
18532 int arg2 ;
18533 wxDC *arg3 = 0 ;
18534 int arg4 ;
18535 int arg5 ;
18536 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
18537 bool arg7 = (bool) (bool)false ;
18538 bool result;
18539 PyObject * obj0 = 0 ;
18540 PyObject * obj1 = 0 ;
18541 PyObject * obj2 = 0 ;
18542 PyObject * obj3 = 0 ;
18543 PyObject * obj4 = 0 ;
18544 PyObject * obj5 = 0 ;
18545 PyObject * obj6 = 0 ;
18546 char *kwnames[] = {
18547 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
18548 };
18549
18550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
18551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18552 if (SWIG_arg_fail(1)) SWIG_fail;
18553 {
18554 arg2 = (int)(SWIG_As_int(obj1));
18555 if (SWIG_arg_fail(2)) SWIG_fail;
18556 }
18557 {
18558 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18559 if (SWIG_arg_fail(3)) SWIG_fail;
18560 if (arg3 == NULL) {
18561 SWIG_null_ref("wxDC");
18562 }
18563 if (SWIG_arg_fail(3)) SWIG_fail;
18564 }
18565 {
18566 arg4 = (int)(SWIG_As_int(obj3));
18567 if (SWIG_arg_fail(4)) SWIG_fail;
18568 }
18569 {
18570 arg5 = (int)(SWIG_As_int(obj4));
18571 if (SWIG_arg_fail(5)) SWIG_fail;
18572 }
18573 if (obj5) {
18574 {
18575 arg6 = (int)(SWIG_As_int(obj5));
18576 if (SWIG_arg_fail(6)) SWIG_fail;
18577 }
18578 }
18579 if (obj6) {
18580 {
18581 arg7 = (bool const)(SWIG_As_bool(obj6));
18582 if (SWIG_arg_fail(7)) SWIG_fail;
18583 }
18584 }
18585 {
18586 PyThreadState* __tstate = wxPyBeginAllowThreads();
18587 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
18588
18589 wxPyEndAllowThreads(__tstate);
18590 if (PyErr_Occurred()) SWIG_fail;
18591 }
18592 {
18593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18594 }
18595 return resultobj;
18596 fail:
18597 return NULL;
18598 }
18599
18600
18601 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
18602 PyObject *resultobj;
18603 wxImageList *arg1 = (wxImageList *) 0 ;
18604 int result;
18605 PyObject * obj0 = 0 ;
18606 char *kwnames[] = {
18607 (char *) "self", NULL
18608 };
18609
18610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
18611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18612 if (SWIG_arg_fail(1)) SWIG_fail;
18613 {
18614 PyThreadState* __tstate = wxPyBeginAllowThreads();
18615 result = (int)(arg1)->GetImageCount();
18616
18617 wxPyEndAllowThreads(__tstate);
18618 if (PyErr_Occurred()) SWIG_fail;
18619 }
18620 {
18621 resultobj = SWIG_From_int((int)(result));
18622 }
18623 return resultobj;
18624 fail:
18625 return NULL;
18626 }
18627
18628
18629 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
18630 PyObject *resultobj;
18631 wxImageList *arg1 = (wxImageList *) 0 ;
18632 int arg2 ;
18633 bool result;
18634 PyObject * obj0 = 0 ;
18635 PyObject * obj1 = 0 ;
18636 char *kwnames[] = {
18637 (char *) "self",(char *) "index", NULL
18638 };
18639
18640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
18641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18642 if (SWIG_arg_fail(1)) SWIG_fail;
18643 {
18644 arg2 = (int)(SWIG_As_int(obj1));
18645 if (SWIG_arg_fail(2)) SWIG_fail;
18646 }
18647 {
18648 PyThreadState* __tstate = wxPyBeginAllowThreads();
18649 result = (bool)(arg1)->Remove(arg2);
18650
18651 wxPyEndAllowThreads(__tstate);
18652 if (PyErr_Occurred()) SWIG_fail;
18653 }
18654 {
18655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18656 }
18657 return resultobj;
18658 fail:
18659 return NULL;
18660 }
18661
18662
18663 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
18664 PyObject *resultobj;
18665 wxImageList *arg1 = (wxImageList *) 0 ;
18666 bool result;
18667 PyObject * obj0 = 0 ;
18668 char *kwnames[] = {
18669 (char *) "self", NULL
18670 };
18671
18672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
18673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18674 if (SWIG_arg_fail(1)) SWIG_fail;
18675 {
18676 PyThreadState* __tstate = wxPyBeginAllowThreads();
18677 result = (bool)(arg1)->RemoveAll();
18678
18679 wxPyEndAllowThreads(__tstate);
18680 if (PyErr_Occurred()) SWIG_fail;
18681 }
18682 {
18683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18684 }
18685 return resultobj;
18686 fail:
18687 return NULL;
18688 }
18689
18690
18691 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18692 PyObject *resultobj;
18693 wxImageList *arg1 = (wxImageList *) 0 ;
18694 int arg2 ;
18695 int *arg3 = 0 ;
18696 int *arg4 = 0 ;
18697 int temp3 ;
18698 int res3 = 0 ;
18699 int temp4 ;
18700 int res4 = 0 ;
18701 PyObject * obj0 = 0 ;
18702 PyObject * obj1 = 0 ;
18703 char *kwnames[] = {
18704 (char *) "self",(char *) "index", NULL
18705 };
18706
18707 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18708 arg4 = &temp4; res4 = SWIG_NEWOBJ;
18709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
18710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18711 if (SWIG_arg_fail(1)) SWIG_fail;
18712 {
18713 arg2 = (int)(SWIG_As_int(obj1));
18714 if (SWIG_arg_fail(2)) SWIG_fail;
18715 }
18716 {
18717 PyThreadState* __tstate = wxPyBeginAllowThreads();
18718 (arg1)->GetSize(arg2,*arg3,*arg4);
18719
18720 wxPyEndAllowThreads(__tstate);
18721 if (PyErr_Occurred()) SWIG_fail;
18722 }
18723 Py_INCREF(Py_None); resultobj = Py_None;
18724 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18725 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18726 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
18727 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
18728 return resultobj;
18729 fail:
18730 return NULL;
18731 }
18732
18733
18734 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
18735 PyObject *obj;
18736 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18737 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
18738 Py_INCREF(obj);
18739 return Py_BuildValue((char *)"");
18740 }
18741 static int _wrap_NORMAL_FONT_set(PyObject *) {
18742 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
18743 return 1;
18744 }
18745
18746
18747 static PyObject *_wrap_NORMAL_FONT_get(void) {
18748 PyObject *pyobj;
18749
18750 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
18751 return pyobj;
18752 }
18753
18754
18755 static int _wrap_SMALL_FONT_set(PyObject *) {
18756 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
18757 return 1;
18758 }
18759
18760
18761 static PyObject *_wrap_SMALL_FONT_get(void) {
18762 PyObject *pyobj;
18763
18764 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
18765 return pyobj;
18766 }
18767
18768
18769 static int _wrap_ITALIC_FONT_set(PyObject *) {
18770 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
18771 return 1;
18772 }
18773
18774
18775 static PyObject *_wrap_ITALIC_FONT_get(void) {
18776 PyObject *pyobj;
18777
18778 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
18779 return pyobj;
18780 }
18781
18782
18783 static int _wrap_SWISS_FONT_set(PyObject *) {
18784 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
18785 return 1;
18786 }
18787
18788
18789 static PyObject *_wrap_SWISS_FONT_get(void) {
18790 PyObject *pyobj;
18791
18792 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
18793 return pyobj;
18794 }
18795
18796
18797 static int _wrap_RED_PEN_set(PyObject *) {
18798 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
18799 return 1;
18800 }
18801
18802
18803 static PyObject *_wrap_RED_PEN_get(void) {
18804 PyObject *pyobj;
18805
18806 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
18807 return pyobj;
18808 }
18809
18810
18811 static int _wrap_CYAN_PEN_set(PyObject *) {
18812 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
18813 return 1;
18814 }
18815
18816
18817 static PyObject *_wrap_CYAN_PEN_get(void) {
18818 PyObject *pyobj;
18819
18820 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
18821 return pyobj;
18822 }
18823
18824
18825 static int _wrap_GREEN_PEN_set(PyObject *) {
18826 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
18827 return 1;
18828 }
18829
18830
18831 static PyObject *_wrap_GREEN_PEN_get(void) {
18832 PyObject *pyobj;
18833
18834 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
18835 return pyobj;
18836 }
18837
18838
18839 static int _wrap_BLACK_PEN_set(PyObject *) {
18840 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
18841 return 1;
18842 }
18843
18844
18845 static PyObject *_wrap_BLACK_PEN_get(void) {
18846 PyObject *pyobj;
18847
18848 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
18849 return pyobj;
18850 }
18851
18852
18853 static int _wrap_WHITE_PEN_set(PyObject *) {
18854 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
18855 return 1;
18856 }
18857
18858
18859 static PyObject *_wrap_WHITE_PEN_get(void) {
18860 PyObject *pyobj;
18861
18862 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
18863 return pyobj;
18864 }
18865
18866
18867 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
18868 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
18869 return 1;
18870 }
18871
18872
18873 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
18874 PyObject *pyobj;
18875
18876 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
18877 return pyobj;
18878 }
18879
18880
18881 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
18882 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
18883 return 1;
18884 }
18885
18886
18887 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
18888 PyObject *pyobj;
18889
18890 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
18891 return pyobj;
18892 }
18893
18894
18895 static int _wrap_GREY_PEN_set(PyObject *) {
18896 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
18897 return 1;
18898 }
18899
18900
18901 static PyObject *_wrap_GREY_PEN_get(void) {
18902 PyObject *pyobj;
18903
18904 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
18905 return pyobj;
18906 }
18907
18908
18909 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
18910 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
18911 return 1;
18912 }
18913
18914
18915 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
18916 PyObject *pyobj;
18917
18918 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
18919 return pyobj;
18920 }
18921
18922
18923 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
18924 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
18925 return 1;
18926 }
18927
18928
18929 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
18930 PyObject *pyobj;
18931
18932 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
18933 return pyobj;
18934 }
18935
18936
18937 static int _wrap_BLUE_BRUSH_set(PyObject *) {
18938 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
18939 return 1;
18940 }
18941
18942
18943 static PyObject *_wrap_BLUE_BRUSH_get(void) {
18944 PyObject *pyobj;
18945
18946 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
18947 return pyobj;
18948 }
18949
18950
18951 static int _wrap_GREEN_BRUSH_set(PyObject *) {
18952 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
18953 return 1;
18954 }
18955
18956
18957 static PyObject *_wrap_GREEN_BRUSH_get(void) {
18958 PyObject *pyobj;
18959
18960 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
18961 return pyobj;
18962 }
18963
18964
18965 static int _wrap_WHITE_BRUSH_set(PyObject *) {
18966 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
18967 return 1;
18968 }
18969
18970
18971 static PyObject *_wrap_WHITE_BRUSH_get(void) {
18972 PyObject *pyobj;
18973
18974 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
18975 return pyobj;
18976 }
18977
18978
18979 static int _wrap_BLACK_BRUSH_set(PyObject *) {
18980 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
18981 return 1;
18982 }
18983
18984
18985 static PyObject *_wrap_BLACK_BRUSH_get(void) {
18986 PyObject *pyobj;
18987
18988 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
18989 return pyobj;
18990 }
18991
18992
18993 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
18994 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
18995 return 1;
18996 }
18997
18998
18999 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
19000 PyObject *pyobj;
19001
19002 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
19003 return pyobj;
19004 }
19005
19006
19007 static int _wrap_CYAN_BRUSH_set(PyObject *) {
19008 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
19009 return 1;
19010 }
19011
19012
19013 static PyObject *_wrap_CYAN_BRUSH_get(void) {
19014 PyObject *pyobj;
19015
19016 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19017 return pyobj;
19018 }
19019
19020
19021 static int _wrap_RED_BRUSH_set(PyObject *) {
19022 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
19023 return 1;
19024 }
19025
19026
19027 static PyObject *_wrap_RED_BRUSH_get(void) {
19028 PyObject *pyobj;
19029
19030 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
19031 return pyobj;
19032 }
19033
19034
19035 static int _wrap_GREY_BRUSH_set(PyObject *) {
19036 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
19037 return 1;
19038 }
19039
19040
19041 static PyObject *_wrap_GREY_BRUSH_get(void) {
19042 PyObject *pyobj;
19043
19044 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19045 return pyobj;
19046 }
19047
19048
19049 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
19050 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
19051 return 1;
19052 }
19053
19054
19055 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
19056 PyObject *pyobj;
19057
19058 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19059 return pyobj;
19060 }
19061
19062
19063 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
19064 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
19065 return 1;
19066 }
19067
19068
19069 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
19070 PyObject *pyobj;
19071
19072 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19073 return pyobj;
19074 }
19075
19076
19077 static int _wrap_BLACK_set(PyObject *) {
19078 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
19079 return 1;
19080 }
19081
19082
19083 static PyObject *_wrap_BLACK_get(void) {
19084 PyObject *pyobj;
19085
19086 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
19087 return pyobj;
19088 }
19089
19090
19091 static int _wrap_WHITE_set(PyObject *) {
19092 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
19093 return 1;
19094 }
19095
19096
19097 static PyObject *_wrap_WHITE_get(void) {
19098 PyObject *pyobj;
19099
19100 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
19101 return pyobj;
19102 }
19103
19104
19105 static int _wrap_RED_set(PyObject *) {
19106 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
19107 return 1;
19108 }
19109
19110
19111 static PyObject *_wrap_RED_get(void) {
19112 PyObject *pyobj;
19113
19114 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
19115 return pyobj;
19116 }
19117
19118
19119 static int _wrap_BLUE_set(PyObject *) {
19120 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
19121 return 1;
19122 }
19123
19124
19125 static PyObject *_wrap_BLUE_get(void) {
19126 PyObject *pyobj;
19127
19128 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
19129 return pyobj;
19130 }
19131
19132
19133 static int _wrap_GREEN_set(PyObject *) {
19134 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
19135 return 1;
19136 }
19137
19138
19139 static PyObject *_wrap_GREEN_get(void) {
19140 PyObject *pyobj;
19141
19142 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
19143 return pyobj;
19144 }
19145
19146
19147 static int _wrap_CYAN_set(PyObject *) {
19148 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
19149 return 1;
19150 }
19151
19152
19153 static PyObject *_wrap_CYAN_get(void) {
19154 PyObject *pyobj;
19155
19156 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
19157 return pyobj;
19158 }
19159
19160
19161 static int _wrap_LIGHT_GREY_set(PyObject *) {
19162 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
19163 return 1;
19164 }
19165
19166
19167 static PyObject *_wrap_LIGHT_GREY_get(void) {
19168 PyObject *pyobj;
19169
19170 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
19171 return pyobj;
19172 }
19173
19174
19175 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
19176 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
19177 return 1;
19178 }
19179
19180
19181 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
19182 PyObject *pyobj;
19183
19184 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
19185 return pyobj;
19186 }
19187
19188
19189 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
19190 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
19191 return 1;
19192 }
19193
19194
19195 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
19196 PyObject *pyobj;
19197
19198 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19199 return pyobj;
19200 }
19201
19202
19203 static int _wrap_CROSS_CURSOR_set(PyObject *) {
19204 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
19205 return 1;
19206 }
19207
19208
19209 static PyObject *_wrap_CROSS_CURSOR_get(void) {
19210 PyObject *pyobj;
19211
19212 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19213 return pyobj;
19214 }
19215
19216
19217 static int _wrap_NullBitmap_set(PyObject *) {
19218 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
19219 return 1;
19220 }
19221
19222
19223 static PyObject *_wrap_NullBitmap_get(void) {
19224 PyObject *pyobj;
19225
19226 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
19227 return pyobj;
19228 }
19229
19230
19231 static int _wrap_NullIcon_set(PyObject *) {
19232 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
19233 return 1;
19234 }
19235
19236
19237 static PyObject *_wrap_NullIcon_get(void) {
19238 PyObject *pyobj;
19239
19240 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
19241 return pyobj;
19242 }
19243
19244
19245 static int _wrap_NullCursor_set(PyObject *) {
19246 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
19247 return 1;
19248 }
19249
19250
19251 static PyObject *_wrap_NullCursor_get(void) {
19252 PyObject *pyobj;
19253
19254 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
19255 return pyobj;
19256 }
19257
19258
19259 static int _wrap_NullPen_set(PyObject *) {
19260 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
19261 return 1;
19262 }
19263
19264
19265 static PyObject *_wrap_NullPen_get(void) {
19266 PyObject *pyobj;
19267
19268 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
19269 return pyobj;
19270 }
19271
19272
19273 static int _wrap_NullBrush_set(PyObject *) {
19274 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
19275 return 1;
19276 }
19277
19278
19279 static PyObject *_wrap_NullBrush_get(void) {
19280 PyObject *pyobj;
19281
19282 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
19283 return pyobj;
19284 }
19285
19286
19287 static int _wrap_NullPalette_set(PyObject *) {
19288 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
19289 return 1;
19290 }
19291
19292
19293 static PyObject *_wrap_NullPalette_get(void) {
19294 PyObject *pyobj;
19295
19296 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
19297 return pyobj;
19298 }
19299
19300
19301 static int _wrap_NullFont_set(PyObject *) {
19302 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
19303 return 1;
19304 }
19305
19306
19307 static PyObject *_wrap_NullFont_get(void) {
19308 PyObject *pyobj;
19309
19310 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
19311 return pyobj;
19312 }
19313
19314
19315 static int _wrap_NullColour_set(PyObject *) {
19316 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
19317 return 1;
19318 }
19319
19320
19321 static PyObject *_wrap_NullColour_get(void) {
19322 PyObject *pyobj;
19323
19324 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
19325 return pyobj;
19326 }
19327
19328
19329 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
19330 PyObject *resultobj;
19331 wxPenList *arg1 = (wxPenList *) 0 ;
19332 wxPen *arg2 = (wxPen *) 0 ;
19333 PyObject * obj0 = 0 ;
19334 PyObject * obj1 = 0 ;
19335 char *kwnames[] = {
19336 (char *) "self",(char *) "pen", NULL
19337 };
19338
19339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
19340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19341 if (SWIG_arg_fail(1)) SWIG_fail;
19342 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19343 if (SWIG_arg_fail(2)) SWIG_fail;
19344 {
19345 PyThreadState* __tstate = wxPyBeginAllowThreads();
19346 (arg1)->AddPen(arg2);
19347
19348 wxPyEndAllowThreads(__tstate);
19349 if (PyErr_Occurred()) SWIG_fail;
19350 }
19351 Py_INCREF(Py_None); resultobj = Py_None;
19352 return resultobj;
19353 fail:
19354 return NULL;
19355 }
19356
19357
19358 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
19359 PyObject *resultobj;
19360 wxPenList *arg1 = (wxPenList *) 0 ;
19361 wxColour *arg2 = 0 ;
19362 int arg3 ;
19363 int arg4 ;
19364 wxPen *result;
19365 wxColour temp2 ;
19366 PyObject * obj0 = 0 ;
19367 PyObject * obj1 = 0 ;
19368 PyObject * obj2 = 0 ;
19369 PyObject * obj3 = 0 ;
19370 char *kwnames[] = {
19371 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
19372 };
19373
19374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19376 if (SWIG_arg_fail(1)) SWIG_fail;
19377 {
19378 arg2 = &temp2;
19379 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19380 }
19381 {
19382 arg3 = (int)(SWIG_As_int(obj2));
19383 if (SWIG_arg_fail(3)) SWIG_fail;
19384 }
19385 {
19386 arg4 = (int)(SWIG_As_int(obj3));
19387 if (SWIG_arg_fail(4)) SWIG_fail;
19388 }
19389 {
19390 PyThreadState* __tstate = wxPyBeginAllowThreads();
19391 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
19392
19393 wxPyEndAllowThreads(__tstate);
19394 if (PyErr_Occurred()) SWIG_fail;
19395 }
19396 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
19397 return resultobj;
19398 fail:
19399 return NULL;
19400 }
19401
19402
19403 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
19404 PyObject *resultobj;
19405 wxPenList *arg1 = (wxPenList *) 0 ;
19406 wxPen *arg2 = (wxPen *) 0 ;
19407 PyObject * obj0 = 0 ;
19408 PyObject * obj1 = 0 ;
19409 char *kwnames[] = {
19410 (char *) "self",(char *) "pen", NULL
19411 };
19412
19413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
19414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19415 if (SWIG_arg_fail(1)) SWIG_fail;
19416 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19417 if (SWIG_arg_fail(2)) SWIG_fail;
19418 {
19419 PyThreadState* __tstate = wxPyBeginAllowThreads();
19420 (arg1)->RemovePen(arg2);
19421
19422 wxPyEndAllowThreads(__tstate);
19423 if (PyErr_Occurred()) SWIG_fail;
19424 }
19425 Py_INCREF(Py_None); resultobj = Py_None;
19426 return resultobj;
19427 fail:
19428 return NULL;
19429 }
19430
19431
19432 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19433 PyObject *resultobj;
19434 wxPenList *arg1 = (wxPenList *) 0 ;
19435 int result;
19436 PyObject * obj0 = 0 ;
19437 char *kwnames[] = {
19438 (char *) "self", NULL
19439 };
19440
19441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
19442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19443 if (SWIG_arg_fail(1)) SWIG_fail;
19444 {
19445 PyThreadState* __tstate = wxPyBeginAllowThreads();
19446 result = (int)(arg1)->GetCount();
19447
19448 wxPyEndAllowThreads(__tstate);
19449 if (PyErr_Occurred()) SWIG_fail;
19450 }
19451 {
19452 resultobj = SWIG_From_int((int)(result));
19453 }
19454 return resultobj;
19455 fail:
19456 return NULL;
19457 }
19458
19459
19460 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
19461 PyObject *obj;
19462 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19463 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
19464 Py_INCREF(obj);
19465 return Py_BuildValue((char *)"");
19466 }
19467 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19468 PyObject *resultobj;
19469 wxBrushList *arg1 = (wxBrushList *) 0 ;
19470 wxBrush *arg2 = (wxBrush *) 0 ;
19471 PyObject * obj0 = 0 ;
19472 PyObject * obj1 = 0 ;
19473 char *kwnames[] = {
19474 (char *) "self",(char *) "brush", NULL
19475 };
19476
19477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
19478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19479 if (SWIG_arg_fail(1)) SWIG_fail;
19480 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19481 if (SWIG_arg_fail(2)) SWIG_fail;
19482 {
19483 PyThreadState* __tstate = wxPyBeginAllowThreads();
19484 (arg1)->AddBrush(arg2);
19485
19486 wxPyEndAllowThreads(__tstate);
19487 if (PyErr_Occurred()) SWIG_fail;
19488 }
19489 Py_INCREF(Py_None); resultobj = Py_None;
19490 return resultobj;
19491 fail:
19492 return NULL;
19493 }
19494
19495
19496 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19497 PyObject *resultobj;
19498 wxBrushList *arg1 = (wxBrushList *) 0 ;
19499 wxColour *arg2 = 0 ;
19500 int arg3 = (int) wxSOLID ;
19501 wxBrush *result;
19502 wxColour temp2 ;
19503 PyObject * obj0 = 0 ;
19504 PyObject * obj1 = 0 ;
19505 PyObject * obj2 = 0 ;
19506 char *kwnames[] = {
19507 (char *) "self",(char *) "colour",(char *) "style", NULL
19508 };
19509
19510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
19511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19512 if (SWIG_arg_fail(1)) SWIG_fail;
19513 {
19514 arg2 = &temp2;
19515 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19516 }
19517 if (obj2) {
19518 {
19519 arg3 = (int)(SWIG_As_int(obj2));
19520 if (SWIG_arg_fail(3)) SWIG_fail;
19521 }
19522 }
19523 {
19524 PyThreadState* __tstate = wxPyBeginAllowThreads();
19525 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
19526
19527 wxPyEndAllowThreads(__tstate);
19528 if (PyErr_Occurred()) SWIG_fail;
19529 }
19530 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
19531 return resultobj;
19532 fail:
19533 return NULL;
19534 }
19535
19536
19537 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19538 PyObject *resultobj;
19539 wxBrushList *arg1 = (wxBrushList *) 0 ;
19540 wxBrush *arg2 = (wxBrush *) 0 ;
19541 PyObject * obj0 = 0 ;
19542 PyObject * obj1 = 0 ;
19543 char *kwnames[] = {
19544 (char *) "self",(char *) "brush", NULL
19545 };
19546
19547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
19548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19549 if (SWIG_arg_fail(1)) SWIG_fail;
19550 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19551 if (SWIG_arg_fail(2)) SWIG_fail;
19552 {
19553 PyThreadState* __tstate = wxPyBeginAllowThreads();
19554 (arg1)->RemoveBrush(arg2);
19555
19556 wxPyEndAllowThreads(__tstate);
19557 if (PyErr_Occurred()) SWIG_fail;
19558 }
19559 Py_INCREF(Py_None); resultobj = Py_None;
19560 return resultobj;
19561 fail:
19562 return NULL;
19563 }
19564
19565
19566 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19567 PyObject *resultobj;
19568 wxBrushList *arg1 = (wxBrushList *) 0 ;
19569 int result;
19570 PyObject * obj0 = 0 ;
19571 char *kwnames[] = {
19572 (char *) "self", NULL
19573 };
19574
19575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
19576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19577 if (SWIG_arg_fail(1)) SWIG_fail;
19578 {
19579 PyThreadState* __tstate = wxPyBeginAllowThreads();
19580 result = (int)(arg1)->GetCount();
19581
19582 wxPyEndAllowThreads(__tstate);
19583 if (PyErr_Occurred()) SWIG_fail;
19584 }
19585 {
19586 resultobj = SWIG_From_int((int)(result));
19587 }
19588 return resultobj;
19589 fail:
19590 return NULL;
19591 }
19592
19593
19594 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
19595 PyObject *obj;
19596 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19597 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
19598 Py_INCREF(obj);
19599 return Py_BuildValue((char *)"");
19600 }
19601 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19602 PyObject *resultobj;
19603 wxColourDatabase *result;
19604 char *kwnames[] = {
19605 NULL
19606 };
19607
19608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
19609 {
19610 if (!wxPyCheckForApp()) SWIG_fail;
19611 PyThreadState* __tstate = wxPyBeginAllowThreads();
19612 result = (wxColourDatabase *)new wxColourDatabase();
19613
19614 wxPyEndAllowThreads(__tstate);
19615 if (PyErr_Occurred()) SWIG_fail;
19616 }
19617 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
19618 return resultobj;
19619 fail:
19620 return NULL;
19621 }
19622
19623
19624 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19625 PyObject *resultobj;
19626 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19627 PyObject * obj0 = 0 ;
19628 char *kwnames[] = {
19629 (char *) "self", NULL
19630 };
19631
19632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
19633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19634 if (SWIG_arg_fail(1)) SWIG_fail;
19635 {
19636 PyThreadState* __tstate = wxPyBeginAllowThreads();
19637 delete arg1;
19638
19639 wxPyEndAllowThreads(__tstate);
19640 if (PyErr_Occurred()) SWIG_fail;
19641 }
19642 Py_INCREF(Py_None); resultobj = Py_None;
19643 return resultobj;
19644 fail:
19645 return NULL;
19646 }
19647
19648
19649 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
19650 PyObject *resultobj;
19651 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19652 wxString *arg2 = 0 ;
19653 wxColour result;
19654 bool temp2 = false ;
19655 PyObject * obj0 = 0 ;
19656 PyObject * obj1 = 0 ;
19657 char *kwnames[] = {
19658 (char *) "self",(char *) "name", NULL
19659 };
19660
19661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
19662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19663 if (SWIG_arg_fail(1)) SWIG_fail;
19664 {
19665 arg2 = wxString_in_helper(obj1);
19666 if (arg2 == NULL) SWIG_fail;
19667 temp2 = true;
19668 }
19669 {
19670 PyThreadState* __tstate = wxPyBeginAllowThreads();
19671 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
19672
19673 wxPyEndAllowThreads(__tstate);
19674 if (PyErr_Occurred()) SWIG_fail;
19675 }
19676 {
19677 wxColour * resultptr;
19678 resultptr = new wxColour((wxColour &)(result));
19679 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19680 }
19681 {
19682 if (temp2)
19683 delete arg2;
19684 }
19685 return resultobj;
19686 fail:
19687 {
19688 if (temp2)
19689 delete arg2;
19690 }
19691 return NULL;
19692 }
19693
19694
19695 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
19696 PyObject *resultobj;
19697 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19698 wxColour *arg2 = 0 ;
19699 wxString result;
19700 wxColour temp2 ;
19701 PyObject * obj0 = 0 ;
19702 PyObject * obj1 = 0 ;
19703 char *kwnames[] = {
19704 (char *) "self",(char *) "colour", NULL
19705 };
19706
19707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
19708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19709 if (SWIG_arg_fail(1)) SWIG_fail;
19710 {
19711 arg2 = &temp2;
19712 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19713 }
19714 {
19715 PyThreadState* __tstate = wxPyBeginAllowThreads();
19716 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
19717
19718 wxPyEndAllowThreads(__tstate);
19719 if (PyErr_Occurred()) SWIG_fail;
19720 }
19721 {
19722 #if wxUSE_UNICODE
19723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19724 #else
19725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19726 #endif
19727 }
19728 return resultobj;
19729 fail:
19730 return NULL;
19731 }
19732
19733
19734 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
19735 PyObject *resultobj;
19736 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19737 wxString *arg2 = 0 ;
19738 wxColour *arg3 = 0 ;
19739 bool temp2 = false ;
19740 wxColour temp3 ;
19741 PyObject * obj0 = 0 ;
19742 PyObject * obj1 = 0 ;
19743 PyObject * obj2 = 0 ;
19744 char *kwnames[] = {
19745 (char *) "self",(char *) "name",(char *) "colour", NULL
19746 };
19747
19748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
19749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19750 if (SWIG_arg_fail(1)) SWIG_fail;
19751 {
19752 arg2 = wxString_in_helper(obj1);
19753 if (arg2 == NULL) SWIG_fail;
19754 temp2 = true;
19755 }
19756 {
19757 arg3 = &temp3;
19758 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19759 }
19760 {
19761 PyThreadState* __tstate = wxPyBeginAllowThreads();
19762 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
19763
19764 wxPyEndAllowThreads(__tstate);
19765 if (PyErr_Occurred()) SWIG_fail;
19766 }
19767 Py_INCREF(Py_None); resultobj = Py_None;
19768 {
19769 if (temp2)
19770 delete arg2;
19771 }
19772 return resultobj;
19773 fail:
19774 {
19775 if (temp2)
19776 delete arg2;
19777 }
19778 return NULL;
19779 }
19780
19781
19782 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
19783 PyObject *resultobj;
19784 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19785 wxString *arg2 = 0 ;
19786 int arg3 ;
19787 int arg4 ;
19788 int arg5 ;
19789 bool temp2 = false ;
19790 PyObject * obj0 = 0 ;
19791 PyObject * obj1 = 0 ;
19792 PyObject * obj2 = 0 ;
19793 PyObject * obj3 = 0 ;
19794 PyObject * obj4 = 0 ;
19795 char *kwnames[] = {
19796 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
19797 };
19798
19799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19801 if (SWIG_arg_fail(1)) SWIG_fail;
19802 {
19803 arg2 = wxString_in_helper(obj1);
19804 if (arg2 == NULL) SWIG_fail;
19805 temp2 = true;
19806 }
19807 {
19808 arg3 = (int)(SWIG_As_int(obj2));
19809 if (SWIG_arg_fail(3)) SWIG_fail;
19810 }
19811 {
19812 arg4 = (int)(SWIG_As_int(obj3));
19813 if (SWIG_arg_fail(4)) SWIG_fail;
19814 }
19815 {
19816 arg5 = (int)(SWIG_As_int(obj4));
19817 if (SWIG_arg_fail(5)) SWIG_fail;
19818 }
19819 {
19820 PyThreadState* __tstate = wxPyBeginAllowThreads();
19821 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
19822
19823 wxPyEndAllowThreads(__tstate);
19824 if (PyErr_Occurred()) SWIG_fail;
19825 }
19826 Py_INCREF(Py_None); resultobj = Py_None;
19827 {
19828 if (temp2)
19829 delete arg2;
19830 }
19831 return resultobj;
19832 fail:
19833 {
19834 if (temp2)
19835 delete arg2;
19836 }
19837 return NULL;
19838 }
19839
19840
19841 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
19842 PyObject *obj;
19843 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19844 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
19845 Py_INCREF(obj);
19846 return Py_BuildValue((char *)"");
19847 }
19848 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
19849 PyObject *resultobj;
19850 wxFontList *arg1 = (wxFontList *) 0 ;
19851 wxFont *arg2 = (wxFont *) 0 ;
19852 PyObject * obj0 = 0 ;
19853 PyObject * obj1 = 0 ;
19854 char *kwnames[] = {
19855 (char *) "self",(char *) "font", NULL
19856 };
19857
19858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
19859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19860 if (SWIG_arg_fail(1)) SWIG_fail;
19861 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19862 if (SWIG_arg_fail(2)) SWIG_fail;
19863 {
19864 PyThreadState* __tstate = wxPyBeginAllowThreads();
19865 (arg1)->AddFont(arg2);
19866
19867 wxPyEndAllowThreads(__tstate);
19868 if (PyErr_Occurred()) SWIG_fail;
19869 }
19870 Py_INCREF(Py_None); resultobj = Py_None;
19871 return resultobj;
19872 fail:
19873 return NULL;
19874 }
19875
19876
19877 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
19878 PyObject *resultobj;
19879 wxFontList *arg1 = (wxFontList *) 0 ;
19880 int arg2 ;
19881 int arg3 ;
19882 int arg4 ;
19883 int arg5 ;
19884 bool arg6 = (bool) false ;
19885 wxString const &arg7_defvalue = wxPyEmptyString ;
19886 wxString *arg7 = (wxString *) &arg7_defvalue ;
19887 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
19888 wxFont *result;
19889 bool temp7 = false ;
19890 PyObject * obj0 = 0 ;
19891 PyObject * obj1 = 0 ;
19892 PyObject * obj2 = 0 ;
19893 PyObject * obj3 = 0 ;
19894 PyObject * obj4 = 0 ;
19895 PyObject * obj5 = 0 ;
19896 PyObject * obj6 = 0 ;
19897 PyObject * obj7 = 0 ;
19898 char *kwnames[] = {
19899 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
19900 };
19901
19902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19904 if (SWIG_arg_fail(1)) SWIG_fail;
19905 {
19906 arg2 = (int)(SWIG_As_int(obj1));
19907 if (SWIG_arg_fail(2)) SWIG_fail;
19908 }
19909 {
19910 arg3 = (int)(SWIG_As_int(obj2));
19911 if (SWIG_arg_fail(3)) SWIG_fail;
19912 }
19913 {
19914 arg4 = (int)(SWIG_As_int(obj3));
19915 if (SWIG_arg_fail(4)) SWIG_fail;
19916 }
19917 {
19918 arg5 = (int)(SWIG_As_int(obj4));
19919 if (SWIG_arg_fail(5)) SWIG_fail;
19920 }
19921 if (obj5) {
19922 {
19923 arg6 = (bool)(SWIG_As_bool(obj5));
19924 if (SWIG_arg_fail(6)) SWIG_fail;
19925 }
19926 }
19927 if (obj6) {
19928 {
19929 arg7 = wxString_in_helper(obj6);
19930 if (arg7 == NULL) SWIG_fail;
19931 temp7 = true;
19932 }
19933 }
19934 if (obj7) {
19935 {
19936 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
19937 if (SWIG_arg_fail(8)) SWIG_fail;
19938 }
19939 }
19940 {
19941 PyThreadState* __tstate = wxPyBeginAllowThreads();
19942 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
19943
19944 wxPyEndAllowThreads(__tstate);
19945 if (PyErr_Occurred()) SWIG_fail;
19946 }
19947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
19948 {
19949 if (temp7)
19950 delete arg7;
19951 }
19952 return resultobj;
19953 fail:
19954 {
19955 if (temp7)
19956 delete arg7;
19957 }
19958 return NULL;
19959 }
19960
19961
19962 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
19963 PyObject *resultobj;
19964 wxFontList *arg1 = (wxFontList *) 0 ;
19965 wxFont *arg2 = (wxFont *) 0 ;
19966 PyObject * obj0 = 0 ;
19967 PyObject * obj1 = 0 ;
19968 char *kwnames[] = {
19969 (char *) "self",(char *) "font", NULL
19970 };
19971
19972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
19973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19974 if (SWIG_arg_fail(1)) SWIG_fail;
19975 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19976 if (SWIG_arg_fail(2)) SWIG_fail;
19977 {
19978 PyThreadState* __tstate = wxPyBeginAllowThreads();
19979 (arg1)->RemoveFont(arg2);
19980
19981 wxPyEndAllowThreads(__tstate);
19982 if (PyErr_Occurred()) SWIG_fail;
19983 }
19984 Py_INCREF(Py_None); resultobj = Py_None;
19985 return resultobj;
19986 fail:
19987 return NULL;
19988 }
19989
19990
19991 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19992 PyObject *resultobj;
19993 wxFontList *arg1 = (wxFontList *) 0 ;
19994 int result;
19995 PyObject * obj0 = 0 ;
19996 char *kwnames[] = {
19997 (char *) "self", NULL
19998 };
19999
20000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
20001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20002 if (SWIG_arg_fail(1)) SWIG_fail;
20003 {
20004 PyThreadState* __tstate = wxPyBeginAllowThreads();
20005 result = (int)(arg1)->GetCount();
20006
20007 wxPyEndAllowThreads(__tstate);
20008 if (PyErr_Occurred()) SWIG_fail;
20009 }
20010 {
20011 resultobj = SWIG_From_int((int)(result));
20012 }
20013 return resultobj;
20014 fail:
20015 return NULL;
20016 }
20017
20018
20019 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
20020 PyObject *obj;
20021 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20022 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
20023 Py_INCREF(obj);
20024 return Py_BuildValue((char *)"");
20025 }
20026 static int _wrap_TheFontList_set(PyObject *) {
20027 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
20028 return 1;
20029 }
20030
20031
20032 static PyObject *_wrap_TheFontList_get(void) {
20033 PyObject *pyobj;
20034
20035 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
20036 return pyobj;
20037 }
20038
20039
20040 static int _wrap_ThePenList_set(PyObject *) {
20041 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
20042 return 1;
20043 }
20044
20045
20046 static PyObject *_wrap_ThePenList_get(void) {
20047 PyObject *pyobj;
20048
20049 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
20050 return pyobj;
20051 }
20052
20053
20054 static int _wrap_TheBrushList_set(PyObject *) {
20055 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
20056 return 1;
20057 }
20058
20059
20060 static PyObject *_wrap_TheBrushList_get(void) {
20061 PyObject *pyobj;
20062
20063 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
20064 return pyobj;
20065 }
20066
20067
20068 static int _wrap_TheColourDatabase_set(PyObject *) {
20069 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
20070 return 1;
20071 }
20072
20073
20074 static PyObject *_wrap_TheColourDatabase_get(void) {
20075 PyObject *pyobj;
20076
20077 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
20078 return pyobj;
20079 }
20080
20081
20082 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
20083 PyObject *resultobj;
20084 wxEffects *result;
20085 char *kwnames[] = {
20086 NULL
20087 };
20088
20089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
20090 {
20091 PyThreadState* __tstate = wxPyBeginAllowThreads();
20092 result = (wxEffects *)new wxEffects();
20093
20094 wxPyEndAllowThreads(__tstate);
20095 if (PyErr_Occurred()) SWIG_fail;
20096 }
20097 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
20098 return resultobj;
20099 fail:
20100 return NULL;
20101 }
20102
20103
20104 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20105 PyObject *resultobj;
20106 wxEffects *arg1 = (wxEffects *) 0 ;
20107 wxColour result;
20108 PyObject * obj0 = 0 ;
20109 char *kwnames[] = {
20110 (char *) "self", NULL
20111 };
20112
20113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
20114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20115 if (SWIG_arg_fail(1)) SWIG_fail;
20116 {
20117 PyThreadState* __tstate = wxPyBeginAllowThreads();
20118 result = ((wxEffects const *)arg1)->GetHighlightColour();
20119
20120 wxPyEndAllowThreads(__tstate);
20121 if (PyErr_Occurred()) SWIG_fail;
20122 }
20123 {
20124 wxColour * resultptr;
20125 resultptr = new wxColour((wxColour &)(result));
20126 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20127 }
20128 return resultobj;
20129 fail:
20130 return NULL;
20131 }
20132
20133
20134 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20135 PyObject *resultobj;
20136 wxEffects *arg1 = (wxEffects *) 0 ;
20137 wxColour result;
20138 PyObject * obj0 = 0 ;
20139 char *kwnames[] = {
20140 (char *) "self", NULL
20141 };
20142
20143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
20144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20145 if (SWIG_arg_fail(1)) SWIG_fail;
20146 {
20147 PyThreadState* __tstate = wxPyBeginAllowThreads();
20148 result = ((wxEffects const *)arg1)->GetLightShadow();
20149
20150 wxPyEndAllowThreads(__tstate);
20151 if (PyErr_Occurred()) SWIG_fail;
20152 }
20153 {
20154 wxColour * resultptr;
20155 resultptr = new wxColour((wxColour &)(result));
20156 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20157 }
20158 return resultobj;
20159 fail:
20160 return NULL;
20161 }
20162
20163
20164 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20165 PyObject *resultobj;
20166 wxEffects *arg1 = (wxEffects *) 0 ;
20167 wxColour result;
20168 PyObject * obj0 = 0 ;
20169 char *kwnames[] = {
20170 (char *) "self", NULL
20171 };
20172
20173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
20174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20175 if (SWIG_arg_fail(1)) SWIG_fail;
20176 {
20177 PyThreadState* __tstate = wxPyBeginAllowThreads();
20178 result = ((wxEffects const *)arg1)->GetFaceColour();
20179
20180 wxPyEndAllowThreads(__tstate);
20181 if (PyErr_Occurred()) SWIG_fail;
20182 }
20183 {
20184 wxColour * resultptr;
20185 resultptr = new wxColour((wxColour &)(result));
20186 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20187 }
20188 return resultobj;
20189 fail:
20190 return NULL;
20191 }
20192
20193
20194 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20195 PyObject *resultobj;
20196 wxEffects *arg1 = (wxEffects *) 0 ;
20197 wxColour result;
20198 PyObject * obj0 = 0 ;
20199 char *kwnames[] = {
20200 (char *) "self", NULL
20201 };
20202
20203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
20204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20205 if (SWIG_arg_fail(1)) SWIG_fail;
20206 {
20207 PyThreadState* __tstate = wxPyBeginAllowThreads();
20208 result = ((wxEffects const *)arg1)->GetMediumShadow();
20209
20210 wxPyEndAllowThreads(__tstate);
20211 if (PyErr_Occurred()) SWIG_fail;
20212 }
20213 {
20214 wxColour * resultptr;
20215 resultptr = new wxColour((wxColour &)(result));
20216 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20217 }
20218 return resultobj;
20219 fail:
20220 return NULL;
20221 }
20222
20223
20224 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20225 PyObject *resultobj;
20226 wxEffects *arg1 = (wxEffects *) 0 ;
20227 wxColour result;
20228 PyObject * obj0 = 0 ;
20229 char *kwnames[] = {
20230 (char *) "self", NULL
20231 };
20232
20233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
20234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20235 if (SWIG_arg_fail(1)) SWIG_fail;
20236 {
20237 PyThreadState* __tstate = wxPyBeginAllowThreads();
20238 result = ((wxEffects const *)arg1)->GetDarkShadow();
20239
20240 wxPyEndAllowThreads(__tstate);
20241 if (PyErr_Occurred()) SWIG_fail;
20242 }
20243 {
20244 wxColour * resultptr;
20245 resultptr = new wxColour((wxColour &)(result));
20246 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20247 }
20248 return resultobj;
20249 fail:
20250 return NULL;
20251 }
20252
20253
20254 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20255 PyObject *resultobj;
20256 wxEffects *arg1 = (wxEffects *) 0 ;
20257 wxColour *arg2 = 0 ;
20258 wxColour temp2 ;
20259 PyObject * obj0 = 0 ;
20260 PyObject * obj1 = 0 ;
20261 char *kwnames[] = {
20262 (char *) "self",(char *) "c", NULL
20263 };
20264
20265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
20266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20267 if (SWIG_arg_fail(1)) SWIG_fail;
20268 {
20269 arg2 = &temp2;
20270 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20271 }
20272 {
20273 PyThreadState* __tstate = wxPyBeginAllowThreads();
20274 (arg1)->SetHighlightColour((wxColour const &)*arg2);
20275
20276 wxPyEndAllowThreads(__tstate);
20277 if (PyErr_Occurred()) SWIG_fail;
20278 }
20279 Py_INCREF(Py_None); resultobj = Py_None;
20280 return resultobj;
20281 fail:
20282 return NULL;
20283 }
20284
20285
20286 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20287 PyObject *resultobj;
20288 wxEffects *arg1 = (wxEffects *) 0 ;
20289 wxColour *arg2 = 0 ;
20290 wxColour temp2 ;
20291 PyObject * obj0 = 0 ;
20292 PyObject * obj1 = 0 ;
20293 char *kwnames[] = {
20294 (char *) "self",(char *) "c", NULL
20295 };
20296
20297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
20298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20299 if (SWIG_arg_fail(1)) SWIG_fail;
20300 {
20301 arg2 = &temp2;
20302 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20303 }
20304 {
20305 PyThreadState* __tstate = wxPyBeginAllowThreads();
20306 (arg1)->SetLightShadow((wxColour const &)*arg2);
20307
20308 wxPyEndAllowThreads(__tstate);
20309 if (PyErr_Occurred()) SWIG_fail;
20310 }
20311 Py_INCREF(Py_None); resultobj = Py_None;
20312 return resultobj;
20313 fail:
20314 return NULL;
20315 }
20316
20317
20318 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20319 PyObject *resultobj;
20320 wxEffects *arg1 = (wxEffects *) 0 ;
20321 wxColour *arg2 = 0 ;
20322 wxColour temp2 ;
20323 PyObject * obj0 = 0 ;
20324 PyObject * obj1 = 0 ;
20325 char *kwnames[] = {
20326 (char *) "self",(char *) "c", NULL
20327 };
20328
20329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
20330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20331 if (SWIG_arg_fail(1)) SWIG_fail;
20332 {
20333 arg2 = &temp2;
20334 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20335 }
20336 {
20337 PyThreadState* __tstate = wxPyBeginAllowThreads();
20338 (arg1)->SetFaceColour((wxColour const &)*arg2);
20339
20340 wxPyEndAllowThreads(__tstate);
20341 if (PyErr_Occurred()) SWIG_fail;
20342 }
20343 Py_INCREF(Py_None); resultobj = Py_None;
20344 return resultobj;
20345 fail:
20346 return NULL;
20347 }
20348
20349
20350 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20351 PyObject *resultobj;
20352 wxEffects *arg1 = (wxEffects *) 0 ;
20353 wxColour *arg2 = 0 ;
20354 wxColour temp2 ;
20355 PyObject * obj0 = 0 ;
20356 PyObject * obj1 = 0 ;
20357 char *kwnames[] = {
20358 (char *) "self",(char *) "c", NULL
20359 };
20360
20361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
20362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20363 if (SWIG_arg_fail(1)) SWIG_fail;
20364 {
20365 arg2 = &temp2;
20366 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20367 }
20368 {
20369 PyThreadState* __tstate = wxPyBeginAllowThreads();
20370 (arg1)->SetMediumShadow((wxColour const &)*arg2);
20371
20372 wxPyEndAllowThreads(__tstate);
20373 if (PyErr_Occurred()) SWIG_fail;
20374 }
20375 Py_INCREF(Py_None); resultobj = Py_None;
20376 return resultobj;
20377 fail:
20378 return NULL;
20379 }
20380
20381
20382 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20383 PyObject *resultobj;
20384 wxEffects *arg1 = (wxEffects *) 0 ;
20385 wxColour *arg2 = 0 ;
20386 wxColour temp2 ;
20387 PyObject * obj0 = 0 ;
20388 PyObject * obj1 = 0 ;
20389 char *kwnames[] = {
20390 (char *) "self",(char *) "c", NULL
20391 };
20392
20393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
20394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20395 if (SWIG_arg_fail(1)) SWIG_fail;
20396 {
20397 arg2 = &temp2;
20398 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20399 }
20400 {
20401 PyThreadState* __tstate = wxPyBeginAllowThreads();
20402 (arg1)->SetDarkShadow((wxColour const &)*arg2);
20403
20404 wxPyEndAllowThreads(__tstate);
20405 if (PyErr_Occurred()) SWIG_fail;
20406 }
20407 Py_INCREF(Py_None); resultobj = Py_None;
20408 return resultobj;
20409 fail:
20410 return NULL;
20411 }
20412
20413
20414 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20415 PyObject *resultobj;
20416 wxEffects *arg1 = (wxEffects *) 0 ;
20417 wxColour *arg2 = 0 ;
20418 wxColour *arg3 = 0 ;
20419 wxColour *arg4 = 0 ;
20420 wxColour *arg5 = 0 ;
20421 wxColour *arg6 = 0 ;
20422 wxColour temp2 ;
20423 wxColour temp3 ;
20424 wxColour temp4 ;
20425 wxColour temp5 ;
20426 wxColour temp6 ;
20427 PyObject * obj0 = 0 ;
20428 PyObject * obj1 = 0 ;
20429 PyObject * obj2 = 0 ;
20430 PyObject * obj3 = 0 ;
20431 PyObject * obj4 = 0 ;
20432 PyObject * obj5 = 0 ;
20433 char *kwnames[] = {
20434 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
20435 };
20436
20437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
20438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20439 if (SWIG_arg_fail(1)) SWIG_fail;
20440 {
20441 arg2 = &temp2;
20442 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20443 }
20444 {
20445 arg3 = &temp3;
20446 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20447 }
20448 {
20449 arg4 = &temp4;
20450 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
20451 }
20452 {
20453 arg5 = &temp5;
20454 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
20455 }
20456 {
20457 arg6 = &temp6;
20458 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
20459 }
20460 {
20461 PyThreadState* __tstate = wxPyBeginAllowThreads();
20462 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
20463
20464 wxPyEndAllowThreads(__tstate);
20465 if (PyErr_Occurred()) SWIG_fail;
20466 }
20467 Py_INCREF(Py_None); resultobj = Py_None;
20468 return resultobj;
20469 fail:
20470 return NULL;
20471 }
20472
20473
20474 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
20475 PyObject *resultobj;
20476 wxEffects *arg1 = (wxEffects *) 0 ;
20477 wxDC *arg2 = 0 ;
20478 wxRect *arg3 = 0 ;
20479 int arg4 = (int) 1 ;
20480 wxRect temp3 ;
20481 PyObject * obj0 = 0 ;
20482 PyObject * obj1 = 0 ;
20483 PyObject * obj2 = 0 ;
20484 PyObject * obj3 = 0 ;
20485 char *kwnames[] = {
20486 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
20487 };
20488
20489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20491 if (SWIG_arg_fail(1)) SWIG_fail;
20492 {
20493 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20494 if (SWIG_arg_fail(2)) SWIG_fail;
20495 if (arg2 == NULL) {
20496 SWIG_null_ref("wxDC");
20497 }
20498 if (SWIG_arg_fail(2)) SWIG_fail;
20499 }
20500 {
20501 arg3 = &temp3;
20502 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
20503 }
20504 if (obj3) {
20505 {
20506 arg4 = (int)(SWIG_As_int(obj3));
20507 if (SWIG_arg_fail(4)) SWIG_fail;
20508 }
20509 }
20510 {
20511 PyThreadState* __tstate = wxPyBeginAllowThreads();
20512 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
20513
20514 wxPyEndAllowThreads(__tstate);
20515 if (PyErr_Occurred()) SWIG_fail;
20516 }
20517 Py_INCREF(Py_None); resultobj = Py_None;
20518 return resultobj;
20519 fail:
20520 return NULL;
20521 }
20522
20523
20524 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
20525 PyObject *resultobj;
20526 wxEffects *arg1 = (wxEffects *) 0 ;
20527 wxRect *arg2 = 0 ;
20528 wxDC *arg3 = 0 ;
20529 wxBitmap *arg4 = 0 ;
20530 bool result;
20531 wxRect temp2 ;
20532 PyObject * obj0 = 0 ;
20533 PyObject * obj1 = 0 ;
20534 PyObject * obj2 = 0 ;
20535 PyObject * obj3 = 0 ;
20536 char *kwnames[] = {
20537 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
20538 };
20539
20540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20542 if (SWIG_arg_fail(1)) SWIG_fail;
20543 {
20544 arg2 = &temp2;
20545 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20546 }
20547 {
20548 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20549 if (SWIG_arg_fail(3)) SWIG_fail;
20550 if (arg3 == NULL) {
20551 SWIG_null_ref("wxDC");
20552 }
20553 if (SWIG_arg_fail(3)) SWIG_fail;
20554 }
20555 {
20556 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
20557 if (SWIG_arg_fail(4)) SWIG_fail;
20558 if (arg4 == NULL) {
20559 SWIG_null_ref("wxBitmap");
20560 }
20561 if (SWIG_arg_fail(4)) SWIG_fail;
20562 }
20563 {
20564 PyThreadState* __tstate = wxPyBeginAllowThreads();
20565 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
20566
20567 wxPyEndAllowThreads(__tstate);
20568 if (PyErr_Occurred()) SWIG_fail;
20569 }
20570 {
20571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20572 }
20573 return resultobj;
20574 fail:
20575 return NULL;
20576 }
20577
20578
20579 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
20580 PyObject *obj;
20581 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20582 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
20583 Py_INCREF(obj);
20584 return Py_BuildValue((char *)"");
20585 }
20586 static PyMethodDef SwigMethods[] = {
20587 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20588 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20589 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20590 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20591 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
20592 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
20593 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20594 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
20595 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20596 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20597 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
20598 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
20599 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
20600 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20601 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20602 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20603 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20604 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20605 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20606 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20607 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20608 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20609 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
20610 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20611 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20612 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20613 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20614 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
20615 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20616 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
20617 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20618 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20619 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20620 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20621 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20622 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20623 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20624 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20625 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20626 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20627 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20628 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20629 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20630 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20631 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20632 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20633 { (char *)"Pen_GetDashCount", (PyCFunction) _wrap_Pen_GetDashCount, METH_VARARGS | METH_KEYWORDS, NULL},
20634 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20635 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20636 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
20637 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20638 { (char *)"new_BrushFromBitmap", (PyCFunction) _wrap_new_BrushFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20639 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20640 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20641 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20642 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20643 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20644 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20645 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20646 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
20647 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20648 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
20649 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20650 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20651 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20652 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20653 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20654 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20655 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
20656 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20657 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20658 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20659 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20660 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20661 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
20662 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20663 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20664 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
20665 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20666 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
20667 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
20668 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
20669 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20670 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20671 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20672 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20673 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20674 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20675 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20676 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
20677 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
20678 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
20679 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20680 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20681 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20682 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20683 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20684 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20685 { (char *)"Icon_LoadFile", (PyCFunction) _wrap_Icon_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
20686 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20687 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20688 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20689 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20690 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20691 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20692 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20693 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20694 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
20695 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20696 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20697 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20698 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20699 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20700 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20701 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20702 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
20703 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20704 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20705 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20706 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20707 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20708 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20709 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20710 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
20711 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20712 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20713 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20714 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20715 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20716 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
20717 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20718 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20719 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20720 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
20721 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20722 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
20723 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
20724 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
20725 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20726 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
20727 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
20728 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
20729 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
20730 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
20731 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20732 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
20733 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
20734 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
20735 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20736 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
20737 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
20738 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20739 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
20740 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
20741 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20742 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20743 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20744 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20745 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
20746 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20747 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20748 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
20749 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
20750 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
20751 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20752 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
20753 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20754 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
20755 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
20756 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
20757 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
20758 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
20759 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
20760 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20761 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20762 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
20763 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
20764 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20765 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20766 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20767 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20768 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20769 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20770 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20771 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20772 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20773 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20774 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20775 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20776 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20777 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20778 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20779 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20780 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
20781 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20782 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20783 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
20784 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
20785 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
20786 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
20787 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
20788 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20789 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20790 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20791 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20792 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
20793 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20794 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20795 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20796 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20797 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20798 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20799 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20800 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
20801 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20802 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
20803 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
20804 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20805 { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
20806 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20807 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20808 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20809 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
20810 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
20811 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
20812 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
20813 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20814 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20815 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20816 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
20817 { (char *)"new_FFont", (PyCFunction) _wrap_new_FFont, METH_VARARGS | METH_KEYWORDS, NULL},
20818 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20819 { (char *)"new_FFontFromPixelSize", (PyCFunction) _wrap_new_FFontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20820 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20821 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20822 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20823 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20824 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20825 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
20826 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20827 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20828 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20829 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20830 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20831 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20832 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20833 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20834 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20835 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20836 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20837 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20838 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20839 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20840 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20841 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20842 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20843 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20844 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20845 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
20846 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20847 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
20848 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
20849 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
20850 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20851 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20852 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20853 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20854 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
20855 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
20856 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
20857 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20858 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
20859 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
20860 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
20861 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
20862 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
20863 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
20864 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
20865 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
20866 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
20867 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
20868 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
20869 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
20870 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
20871 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
20872 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
20873 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
20874 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20875 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20876 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
20877 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20878 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
20879 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20880 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
20881 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
20882 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
20883 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
20884 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
20885 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20886 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
20887 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20888 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20889 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
20890 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
20891 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
20892 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
20893 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
20894 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
20895 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
20896 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
20897 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
20898 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
20899 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
20900 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
20901 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
20902 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
20903 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
20904 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
20905 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
20906 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20907 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20908 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20909 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
20910 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
20911 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
20912 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20913 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
20914 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20915 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
20916 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
20917 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
20918 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20919 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20920 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20921 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20922 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
20923 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20924 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20925 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
20926 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20927 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
20928 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
20929 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
20930 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
20931 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20932 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20933 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20934 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20935 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20936 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
20937 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20938 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
20939 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20940 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
20941 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20942 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20943 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20944 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20945 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
20946 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
20947 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
20948 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
20949 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
20950 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
20951 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
20952 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
20953 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
20954 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
20955 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
20956 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20957 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
20958 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20959 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20960 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
20961 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
20962 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20963 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20964 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
20965 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20966 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20967 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20968 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20969 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20970 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
20971 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20972 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20973 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
20974 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20975 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
20976 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
20977 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
20978 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
20979 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
20980 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
20981 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
20982 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
20983 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20984 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20985 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20986 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
20987 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20988 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
20989 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20990 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20991 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20992 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
20993 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20994 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20995 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20996 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20997 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
20998 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
20999 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21000 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21001 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21002 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21003 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21004 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21005 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21006 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21007 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21008 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21009 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21010 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21011 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
21012 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21013 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21014 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21015 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21016 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21017 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21018 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
21019 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
21020 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
21021 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
21022 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21023 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
21024 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
21025 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
21026 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
21027 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
21028 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
21029 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
21030 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
21031 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
21032 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
21033 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
21034 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
21035 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
21036 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
21037 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
21038 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21039 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
21040 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
21041 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
21042 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21043 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21044 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
21045 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
21046 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
21047 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21048 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
21049 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
21050 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
21051 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
21052 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
21053 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
21054 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21055 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21056 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21057 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21058 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
21059 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21060 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
21061 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
21062 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
21063 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
21064 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
21065 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21066 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21067 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
21068 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
21069 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21070 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21071 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21072 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
21073 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
21074 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
21075 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
21076 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
21077 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21078 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
21079 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
21080 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
21081 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
21082 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21083 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
21084 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21085 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21086 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21087 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21088 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
21089 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21090 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21091 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
21092 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
21093 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
21094 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
21095 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
21096 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
21097 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
21098 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
21099 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21100 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
21101 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
21102 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21103 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21104 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21105 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21106 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21107 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21108 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21109 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21110 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21111 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21112 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21113 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
21114 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21115 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
21116 { NULL, NULL, 0, NULL }
21117 };
21118
21119
21120 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21121
21122 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
21123 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
21124 }
21125 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
21126 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
21127 }
21128 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
21129 return (void *)((wxGDIObject *) ((wxIcon *) x));
21130 }
21131 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
21132 return (void *)((wxGDIObject *) ((wxPalette *) x));
21133 }
21134 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
21135 return (void *)((wxGDIObject *) ((wxPen *) x));
21136 }
21137 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
21138 return (void *)((wxGDIObject *) ((wxFont *) x));
21139 }
21140 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
21141 return (void *)((wxGDIObject *) ((wxCursor *) x));
21142 }
21143 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
21144 return (void *)((wxGDIObject *) ((wxBitmap *) x));
21145 }
21146 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
21147 return (void *)((wxGDIObject *) ((wxRegion *) x));
21148 }
21149 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
21150 return (void *)((wxGDIObject *) ((wxBrush *) x));
21151 }
21152 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
21153 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
21154 }
21155 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
21156 return (void *)((wxDC *) ((wxScreenDC *) x));
21157 }
21158 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
21159 return (void *)((wxDC *) ((wxMirrorDC *) x));
21160 }
21161 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
21162 return (void *)((wxDC *) ((wxMemoryDC *) x));
21163 }
21164 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
21165 return (void *)((wxDC *) ((wxWindowDC *) x));
21166 }
21167 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
21168 return (void *)((wxDC *) ((wxMetaFileDC *) x));
21169 }
21170 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
21171 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21172 }
21173 static void *_p_wxClientDCTo_p_wxDC(void *x) {
21174 return (void *)((wxDC *) ((wxClientDC *) x));
21175 }
21176 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
21177 return (void *)((wxDC *) ((wxPaintDC *) x));
21178 }
21179 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
21180 return (void *)((wxDC *) ((wxPostScriptDC *) x));
21181 }
21182 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
21183 return (void *)((wxDC *) ((wxPrinterDC *) x));
21184 }
21185 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
21186 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
21187 }
21188 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21189 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21190 }
21191 static void *_p_wxPenTo_p_wxObject(void *x) {
21192 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
21193 }
21194 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
21195 return (void *)((wxObject *) ((wxRegionIterator *) x));
21196 }
21197 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21198 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21199 }
21200 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21201 return (void *)((wxObject *) ((wxSizerItem *) x));
21202 }
21203 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
21204 return (void *)((wxObject *) ((wxColourDatabase *) x));
21205 }
21206 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21207 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21208 }
21209 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21210 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21211 }
21212 static void *_p_wxIconTo_p_wxObject(void *x) {
21213 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
21214 }
21215 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21216 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21217 }
21218 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21219 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21220 }
21221 static void *_p_wxSizerTo_p_wxObject(void *x) {
21222 return (void *)((wxObject *) ((wxSizer *) x));
21223 }
21224 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21225 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21226 }
21227 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21228 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21229 }
21230 static void *_p_wxPenListTo_p_wxObject(void *x) {
21231 return (void *)((wxObject *) ((wxPenList *) x));
21232 }
21233 static void *_p_wxEventTo_p_wxObject(void *x) {
21234 return (void *)((wxObject *) ((wxEvent *) x));
21235 }
21236 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21237 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21238 }
21239 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21240 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21241 }
21242 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21243 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21244 }
21245 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21246 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21247 }
21248 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21249 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21250 }
21251 static void *_p_wxDCTo_p_wxObject(void *x) {
21252 return (void *)((wxObject *) ((wxDC *) x));
21253 }
21254 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21255 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21256 }
21257 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21258 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21259 }
21260 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21261 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21262 }
21263 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21264 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21265 }
21266 static void *_p_wxControlTo_p_wxObject(void *x) {
21267 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21268 }
21269 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21270 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21271 }
21272 static void *_p_wxClientDCTo_p_wxObject(void *x) {
21273 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
21274 }
21275 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21276 return (void *)((wxObject *) ((wxFSFile *) x));
21277 }
21278 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
21279 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
21280 }
21281 static void *_p_wxRegionTo_p_wxObject(void *x) {
21282 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
21283 }
21284 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21285 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21286 }
21287 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
21288 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
21289 }
21290 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
21291 return (void *)((wxObject *) ((wxGDIObject *) x));
21292 }
21293 static void *_p_wxEffectsTo_p_wxObject(void *x) {
21294 return (void *)((wxObject *) ((wxEffects *) x));
21295 }
21296 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21297 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21298 }
21299 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21300 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21301 }
21302 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
21303 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
21304 }
21305 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21306 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21307 }
21308 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21309 return (void *)((wxObject *) ((wxMenuItem *) x));
21310 }
21311 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21312 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21313 }
21314 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21315 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21316 }
21317 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21318 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21319 }
21320 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21321 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21322 }
21323 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21324 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21325 }
21326 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21327 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21328 }
21329 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21330 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21331 }
21332 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21333 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21334 }
21335 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21336 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21337 }
21338 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21339 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21340 }
21341 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21342 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21343 }
21344 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21345 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21346 }
21347 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21348 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21349 }
21350 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21351 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21352 }
21353 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21354 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21355 }
21356 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21357 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21358 }
21359 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21360 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21361 }
21362 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21363 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21364 }
21365 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21366 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21367 }
21368 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21369 return (void *)((wxObject *) ((wxImageHandler *) x));
21370 }
21371 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21372 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21373 }
21374 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21375 return (void *)((wxObject *) ((wxEvtHandler *) x));
21376 }
21377 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
21378 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21379 }
21380 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
21381 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
21382 }
21383 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
21384 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
21385 }
21386 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
21387 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
21388 }
21389 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21390 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21391 }
21392 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21393 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21394 }
21395 static void *_p_wxImageTo_p_wxObject(void *x) {
21396 return (void *)((wxObject *) ((wxImage *) x));
21397 }
21398 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21399 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21400 }
21401 static void *_p_wxPaletteTo_p_wxObject(void *x) {
21402 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
21403 }
21404 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
21405 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
21406 }
21407 static void *_p_wxImageListTo_p_wxObject(void *x) {
21408 return (void *)((wxObject *) ((wxImageList *) x));
21409 }
21410 static void *_p_wxCursorTo_p_wxObject(void *x) {
21411 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
21412 }
21413 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
21414 return (void *)((wxObject *) ((wxEncodingConverter *) x));
21415 }
21416 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
21417 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
21418 }
21419 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21420 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21421 }
21422 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21423 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21424 }
21425 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21426 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21427 }
21428 static void *_p_wxWindowTo_p_wxObject(void *x) {
21429 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21430 }
21431 static void *_p_wxMenuTo_p_wxObject(void *x) {
21432 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21433 }
21434 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21435 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21436 }
21437 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
21438 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
21439 }
21440 static void *_p_wxBrushListTo_p_wxObject(void *x) {
21441 return (void *)((wxObject *) ((wxBrushList *) x));
21442 }
21443 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21444 return (void *)((wxObject *) ((wxFileSystem *) x));
21445 }
21446 static void *_p_wxBitmapTo_p_wxObject(void *x) {
21447 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
21448 }
21449 static void *_p_wxMaskTo_p_wxObject(void *x) {
21450 return (void *)((wxObject *) ((wxMask *) x));
21451 }
21452 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21453 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21454 }
21455 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21456 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21457 }
21458 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21459 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21460 }
21461 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21462 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21463 }
21464 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21465 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21466 }
21467 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21468 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21469 }
21470 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21471 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21472 }
21473 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21474 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21475 }
21476 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21477 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21478 }
21479 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21480 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21481 }
21482 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21483 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21484 }
21485 static void *_p_wxFontTo_p_wxObject(void *x) {
21486 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
21487 }
21488 static void *_p_wxBrushTo_p_wxObject(void *x) {
21489 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
21490 }
21491 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
21492 return (void *)((wxObject *) ((wxMetaFile *) x));
21493 }
21494 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21495 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21496 }
21497 static void *_p_wxColourTo_p_wxObject(void *x) {
21498 return (void *)((wxObject *) ((wxColour *) x));
21499 }
21500 static void *_p_wxFontListTo_p_wxObject(void *x) {
21501 return (void *)((wxObject *) ((wxFontList *) x));
21502 }
21503 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21504 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21505 }
21506 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21507 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21508 }
21509 static void *_p_wxControlTo_p_wxWindow(void *x) {
21510 return (void *)((wxWindow *) ((wxControl *) x));
21511 }
21512 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21513 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21514 }
21515 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
21516 return (void *)((wxWindow *) ((wxMenuBar *) x));
21517 }
21518 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}};
21519 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}};
21520 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}};
21521 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}};
21522 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}};
21523 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}};
21524 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}};
21525 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}};
21526 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}};
21527 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}};
21528 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}};
21529 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}};
21530 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}};
21531 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}};
21532 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}};
21533 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}};
21534 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}};
21535 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}};
21536 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}};
21537 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}};
21538 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}};
21539 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}};
21540 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}};
21541 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxRegionIterator", _p_wxRegionIteratorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPen", _p_wxPenTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColourDatabase", _p_wxColourDatabaseTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPenList", _p_wxPenListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMask", _p_wxMaskTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFont", _p_wxFontTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClientDC", _p_wxClientDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMemoryDC", _p_wxMemoryDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxRegion", _p_wxRegionTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDC", _p_wxDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIcon", _p_wxIconTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDC", _p_wxWindowDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGDIObject", _p_wxGDIObjectTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEffects", _p_wxEffectsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPostScriptDC", _p_wxPostScriptDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintDC", _p_wxPaintDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBufferedPaintDC", _p_wxBufferedPaintDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrinterDC", _p_wxPrinterDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScreenDC", _p_wxScreenDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBufferedDC", _p_wxBufferedDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPalette", _p_wxPaletteTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageList", _p_wxImageListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCursor", _p_wxCursorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxMirrorDC", _p_wxMirrorDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEncodingConverter", _p_wxEncodingConverterTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMetaFileDC", _p_wxMetaFileDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBrushList", _p_wxBrushListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBitmap", _p_wxBitmapTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBrush", _p_wxBrushTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMetaFile", _p_wxMetaFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColour", _p_wxColourTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFontList", _p_wxFontListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
21542 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}};
21543 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}};
21544 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}};
21545 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}};
21546 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}};
21547 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}};
21548 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}};
21549 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}};
21550 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}};
21551 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}};
21552 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}};
21553 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}};
21554 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}};
21555 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}};
21556 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}};
21557 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}};
21558 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}};
21559 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}};
21560 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}};
21561 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}};
21562 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}};
21563 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}};
21564 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}};
21565 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}};
21566 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}};
21567 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}};
21568 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}};
21569 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}};
21570 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}};
21571 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}};
21572 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}};
21573 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}};
21574 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}};
21575 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}};
21576 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}};
21577 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}};
21578 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}};
21579 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}};
21580
21581 static swig_type_info *swig_types_initial[] = {
21582 _swigt__p_wxPostScriptDC,
21583 _swigt__p_wxBrush,
21584 _swigt__p_wxColour,
21585 _swigt__p_wxDC,
21586 _swigt__p_wxMirrorDC,
21587 _swigt__p_form_ops_t,
21588 _swigt__p_wxDuplexMode,
21589 _swigt__p_wxPyFontEnumerator,
21590 _swigt__p_char,
21591 _swigt__p_wxIconLocation,
21592 _swigt__p_wxImage,
21593 _swigt__p_wxMetaFileDC,
21594 _swigt__p_wxMask,
21595 _swigt__p_wxSize,
21596 _swigt__p_wxFont,
21597 _swigt__p_wxWindow,
21598 _swigt__p_double,
21599 _swigt__p_wxMemoryDC,
21600 _swigt__p_wxFontMapper,
21601 _swigt__p_wxEffects,
21602 _swigt__p_wxNativeEncodingInfo,
21603 _swigt__p_wxPalette,
21604 _swigt__p_wxBitmap,
21605 _swigt__p_wxObject,
21606 _swigt__p_wxRegionIterator,
21607 _swigt__p_wxRect,
21608 _swigt__p_wxPaperSize,
21609 _swigt__p_wxString,
21610 _swigt__unsigned_int,
21611 _swigt__p_unsigned_int,
21612 _swigt__p_wxPrinterDC,
21613 _swigt__p_wxIconBundle,
21614 _swigt__p_wxPoint,
21615 _swigt__p_wxDash,
21616 _swigt__p_wxScreenDC,
21617 _swigt__p_wxCursor,
21618 _swigt__p_wxClientDC,
21619 _swigt__p_wxBufferedDC,
21620 _swigt__p_wxImageList,
21621 _swigt__p_unsigned_char,
21622 _swigt__p_wxGDIObject,
21623 _swigt__p_wxIcon,
21624 _swigt__p_wxLocale,
21625 _swigt__ptrdiff_t,
21626 _swigt__std__ptrdiff_t,
21627 _swigt__p_wxRegion,
21628 _swigt__p_wxConfigBase,
21629 _swigt__p_wxLanguageInfo,
21630 _swigt__p_wxWindowDC,
21631 _swigt__p_wxPrintData,
21632 _swigt__p_wxBrushList,
21633 _swigt__p_wxFontList,
21634 _swigt__p_wxPen,
21635 _swigt__p_wxBufferedPaintDC,
21636 _swigt__p_wxPaintDC,
21637 _swigt__p_wxPenList,
21638 _swigt__p_int,
21639 _swigt__p_wxMetaFile,
21640 _swigt__p_unsigned_long,
21641 _swigt__p_wxNativeFontInfo,
21642 _swigt__p_wxEncodingConverter,
21643 _swigt__p_wxColourDatabase,
21644 0
21645 };
21646
21647
21648 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
21649
21650 static swig_const_info swig_const_table[] = {
21651 {0, 0, 0, 0.0, 0, 0}};
21652
21653 #ifdef __cplusplus
21654 }
21655 #endif
21656
21657
21658 #ifdef __cplusplus
21659 extern "C" {
21660 #endif
21661
21662 /* Python-specific SWIG API */
21663 #define SWIG_newvarlink() SWIG_Python_newvarlink()
21664 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
21665 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
21666
21667 /* -----------------------------------------------------------------------------
21668 * global variable support code.
21669 * ----------------------------------------------------------------------------- */
21670
21671 typedef struct swig_globalvar {
21672 char *name; /* Name of global variable */
21673 PyObject *(*get_attr)(); /* Return the current value */
21674 int (*set_attr)(PyObject *); /* Set the value */
21675 struct swig_globalvar *next;
21676 } swig_globalvar;
21677
21678 typedef struct swig_varlinkobject {
21679 PyObject_HEAD
21680 swig_globalvar *vars;
21681 } swig_varlinkobject;
21682
21683 static PyObject *
21684 swig_varlink_repr(swig_varlinkobject *v) {
21685 v = v;
21686 return PyString_FromString("<Swig global variables>");
21687 }
21688
21689 static int
21690 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
21691 swig_globalvar *var;
21692 flags = flags;
21693 fprintf(fp,"Swig global variables { ");
21694 for (var = v->vars; var; var=var->next) {
21695 fprintf(fp,"%s", var->name);
21696 if (var->next) fprintf(fp,", ");
21697 }
21698 fprintf(fp," }\n");
21699 return 0;
21700 }
21701
21702 static PyObject *
21703 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
21704 swig_globalvar *var = v->vars;
21705 while (var) {
21706 if (strcmp(var->name,n) == 0) {
21707 return (*var->get_attr)();
21708 }
21709 var = var->next;
21710 }
21711 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21712 return NULL;
21713 }
21714
21715 static int
21716 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
21717 swig_globalvar *var = v->vars;
21718 while (var) {
21719 if (strcmp(var->name,n) == 0) {
21720 return (*var->set_attr)(p);
21721 }
21722 var = var->next;
21723 }
21724 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21725 return 1;
21726 }
21727
21728 static PyTypeObject varlinktype = {
21729 PyObject_HEAD_INIT(0)
21730 0, /* Number of items in variable part (ob_size) */
21731 (char *)"swigvarlink", /* Type name (tp_name) */
21732 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
21733 0, /* Itemsize (tp_itemsize) */
21734 0, /* Deallocator (tp_dealloc) */
21735 (printfunc) swig_varlink_print, /* Print (tp_print) */
21736 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
21737 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
21738 0, /* tp_compare */
21739 (reprfunc) swig_varlink_repr, /* tp_repr */
21740 0, /* tp_as_number */
21741 0, /* tp_as_sequence */
21742 0, /* tp_as_mapping */
21743 0, /* tp_hash */
21744 0, /* tp_call */
21745 0, /* tp_str */
21746 0, /* tp_getattro */
21747 0, /* tp_setattro */
21748 0, /* tp_as_buffer */
21749 0, /* tp_flags */
21750 0, /* tp_doc */
21751 #if PY_VERSION_HEX >= 0x02000000
21752 0, /* tp_traverse */
21753 0, /* tp_clear */
21754 #endif
21755 #if PY_VERSION_HEX >= 0x02010000
21756 0, /* tp_richcompare */
21757 0, /* tp_weaklistoffset */
21758 #endif
21759 #if PY_VERSION_HEX >= 0x02020000
21760 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
21761 #endif
21762 #if PY_VERSION_HEX >= 0x02030000
21763 0, /* tp_del */
21764 #endif
21765 #ifdef COUNT_ALLOCS
21766 0,0,0,0 /* tp_alloc -> tp_next */
21767 #endif
21768 };
21769
21770 /* Create a variable linking object for use later */
21771 static PyObject *
21772 SWIG_Python_newvarlink(void) {
21773 swig_varlinkobject *result = 0;
21774 result = PyMem_NEW(swig_varlinkobject,1);
21775 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
21776 result->ob_type = &varlinktype;
21777 result->vars = 0;
21778 result->ob_refcnt = 0;
21779 Py_XINCREF((PyObject *) result);
21780 return ((PyObject*) result);
21781 }
21782
21783 static void
21784 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
21785 swig_varlinkobject *v;
21786 swig_globalvar *gv;
21787 v= (swig_varlinkobject *) p;
21788 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
21789 gv->name = (char *) malloc(strlen(name)+1);
21790 strcpy(gv->name,name);
21791 gv->get_attr = get_attr;
21792 gv->set_attr = set_attr;
21793 gv->next = v->vars;
21794 v->vars = gv;
21795 }
21796
21797 /* -----------------------------------------------------------------------------
21798 * constants/methods manipulation
21799 * ----------------------------------------------------------------------------- */
21800
21801 /* Install Constants */
21802 static void
21803 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
21804 PyObject *obj = 0;
21805 size_t i;
21806 for (i = 0; constants[i].type; i++) {
21807 switch(constants[i].type) {
21808 case SWIG_PY_INT:
21809 obj = PyInt_FromLong(constants[i].lvalue);
21810 break;
21811 case SWIG_PY_FLOAT:
21812 obj = PyFloat_FromDouble(constants[i].dvalue);
21813 break;
21814 case SWIG_PY_STRING:
21815 if (constants[i].pvalue) {
21816 obj = PyString_FromString((char *) constants[i].pvalue);
21817 } else {
21818 Py_INCREF(Py_None);
21819 obj = Py_None;
21820 }
21821 break;
21822 case SWIG_PY_POINTER:
21823 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
21824 break;
21825 case SWIG_PY_BINARY:
21826 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
21827 break;
21828 default:
21829 obj = 0;
21830 break;
21831 }
21832 if (obj) {
21833 PyDict_SetItemString(d,constants[i].name,obj);
21834 Py_DECREF(obj);
21835 }
21836 }
21837 }
21838
21839 /* -----------------------------------------------------------------------------*/
21840 /* Fix SwigMethods to carry the callback ptrs when needed */
21841 /* -----------------------------------------------------------------------------*/
21842
21843 static void
21844 SWIG_Python_FixMethods(PyMethodDef *methods,
21845 swig_const_info *const_table,
21846 swig_type_info **types,
21847 swig_type_info **types_initial) {
21848 size_t i;
21849 for (i = 0; methods[i].ml_name; ++i) {
21850 char *c = methods[i].ml_doc;
21851 if (c && (c = strstr(c, "swig_ptr: "))) {
21852 int j;
21853 swig_const_info *ci = 0;
21854 char *name = c + 10;
21855 for (j = 0; const_table[j].type; j++) {
21856 if (strncmp(const_table[j].name, name,
21857 strlen(const_table[j].name)) == 0) {
21858 ci = &(const_table[j]);
21859 break;
21860 }
21861 }
21862 if (ci) {
21863 size_t shift = (ci->ptype) - types;
21864 swig_type_info *ty = types_initial[shift];
21865 size_t ldoc = (c - methods[i].ml_doc);
21866 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
21867 char *ndoc = (char*)malloc(ldoc + lptr + 10);
21868 char *buff = ndoc;
21869 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
21870 strncpy(buff, methods[i].ml_doc, ldoc);
21871 buff += ldoc;
21872 strncpy(buff, "swig_ptr: ", 10);
21873 buff += 10;
21874 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
21875 methods[i].ml_doc = ndoc;
21876 }
21877 }
21878 }
21879 }
21880
21881 /* -----------------------------------------------------------------------------*
21882 * Initialize type list
21883 * -----------------------------------------------------------------------------*/
21884
21885 #if PY_MAJOR_VERSION < 2
21886 /* PyModule_AddObject function was introduced in Python 2.0. The following function
21887 is copied out of Python/modsupport.c in python version 2.3.4 */
21888 static int
21889 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
21890 {
21891 PyObject *dict;
21892 if (!PyModule_Check(m)) {
21893 PyErr_SetString(PyExc_TypeError,
21894 "PyModule_AddObject() needs module as first arg");
21895 return -1;
21896 }
21897 if (!o) {
21898 PyErr_SetString(PyExc_TypeError,
21899 "PyModule_AddObject() needs non-NULL value");
21900 return -1;
21901 }
21902
21903 dict = PyModule_GetDict(m);
21904 if (dict == NULL) {
21905 /* Internal error -- modules must have a dict! */
21906 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
21907 PyModule_GetName(m));
21908 return -1;
21909 }
21910 if (PyDict_SetItemString(dict, name, o))
21911 return -1;
21912 Py_DECREF(o);
21913 return 0;
21914 }
21915 #endif
21916
21917 static swig_type_info **
21918 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
21919 static PyMethodDef swig_empty_runtime_method_table[] = {
21920 {
21921 NULL, NULL, 0, NULL
21922 }
21923 };/* Sentinel */
21924
21925 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
21926 swig_empty_runtime_method_table);
21927 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
21928 if (pointer && module) {
21929 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
21930 }
21931 return type_list_handle;
21932 }
21933
21934 static swig_type_info **
21935 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
21936 swig_type_info **type_pointer;
21937
21938 /* first check if module already created */
21939 type_pointer = SWIG_Python_GetTypeListHandle();
21940 if (type_pointer) {
21941 return type_pointer;
21942 } else {
21943 /* create a new module and variable */
21944 return SWIG_Python_SetTypeListHandle(type_list_handle);
21945 }
21946 }
21947
21948 #ifdef __cplusplus
21949 }
21950 #endif
21951
21952 /* -----------------------------------------------------------------------------*
21953 * Partial Init method
21954 * -----------------------------------------------------------------------------*/
21955
21956 #ifdef SWIG_LINK_RUNTIME
21957 #ifdef __cplusplus
21958 extern "C"
21959 #endif
21960 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
21961 #endif
21962
21963 #ifdef __cplusplus
21964 extern "C"
21965 #endif
21966 SWIGEXPORT(void) SWIG_init(void) {
21967 static PyObject *SWIG_globals = 0;
21968 static int typeinit = 0;
21969 PyObject *m, *d;
21970 int i;
21971 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
21972
21973 /* Fix SwigMethods to carry the callback ptrs when needed */
21974 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
21975
21976 m = Py_InitModule((char *) SWIG_name, SwigMethods);
21977 d = PyModule_GetDict(m);
21978
21979 if (!typeinit) {
21980 #ifdef SWIG_LINK_RUNTIME
21981 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
21982 #else
21983 # ifndef SWIG_STATIC_RUNTIME
21984 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
21985 # endif
21986 #endif
21987 for (i = 0; swig_types_initial[i]; i++) {
21988 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
21989 }
21990 typeinit = 1;
21991 }
21992 SWIG_InstallConstants(d,swig_const_table);
21993
21994 {
21995 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
21996 }
21997 {
21998 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
21999 }
22000 {
22001 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
22002 }
22003 {
22004 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
22005 }
22006 {
22007 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
22008 }
22009 {
22010 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
22011 }
22012 {
22013 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
22014 }
22015 {
22016 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
22017 }
22018 {
22019 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
22020 }
22021 {
22022 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
22023 }
22024 {
22025 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
22026 }
22027 {
22028 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
22029 }
22030 {
22031 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
22032 }
22033 {
22034 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
22035 }
22036 {
22037 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
22038 }
22039 {
22040 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
22041 }
22042 {
22043 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
22044 }
22045 {
22046 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
22047 }
22048 {
22049 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
22050 }
22051 {
22052 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
22053 }
22054 {
22055 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
22056 }
22057 {
22058 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
22059 }
22060 {
22061 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
22062 }
22063 {
22064 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
22065 }
22066 {
22067 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
22068 }
22069 {
22070 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
22071 }
22072 {
22073 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
22074 }
22075 {
22076 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
22077 }
22078 {
22079 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
22080 }
22081 {
22082 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
22083 }
22084 {
22085 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
22086 }
22087 {
22088 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
22089 }
22090 {
22091 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
22092 }
22093 {
22094 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
22095 }
22096 {
22097 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
22098 }
22099 {
22100 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
22101 }
22102 {
22103 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
22104 }
22105 {
22106 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
22107 }
22108 {
22109 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
22110 }
22111 {
22112 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
22113 }
22114 {
22115 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
22116 }
22117 {
22118 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
22119 }
22120 {
22121 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
22122 }
22123 {
22124 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
22125 }
22126 {
22127 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
22128 }
22129 {
22130 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
22131 }
22132 {
22133 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
22134 }
22135 {
22136 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
22137 }
22138 {
22139 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
22140 }
22141 {
22142 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
22143 }
22144 {
22145 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
22146 }
22147 {
22148 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
22149 }
22150 {
22151 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
22152 }
22153 {
22154 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
22155 }
22156 {
22157 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
22158 }
22159 {
22160 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
22161 }
22162 {
22163 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
22164 }
22165 {
22166 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
22167 }
22168 {
22169 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
22170 }
22171 {
22172 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
22173 }
22174 {
22175 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
22176 }
22177 {
22178 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
22179 }
22180 {
22181 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
22182 }
22183 {
22184 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
22185 }
22186 {
22187 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
22188 }
22189 {
22190 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
22191 }
22192 {
22193 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
22194 }
22195 {
22196 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
22197 }
22198 {
22199 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
22200 }
22201 {
22202 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
22203 }
22204 {
22205 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
22206 }
22207 {
22208 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
22209 }
22210 {
22211 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
22212 }
22213 {
22214 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
22215 }
22216 {
22217 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
22218 }
22219 {
22220 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
22221 }
22222 {
22223 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
22224 }
22225 {
22226 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
22227 }
22228 {
22229 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
22230 }
22231 {
22232 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
22233 }
22234 {
22235 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
22236 }
22237 {
22238 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
22239 }
22240 {
22241 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
22242 }
22243 {
22244 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
22245 }
22246 {
22247 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
22248 }
22249 {
22250 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
22251 }
22252 {
22253 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
22254 }
22255 {
22256 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
22257 }
22258 {
22259 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
22260 }
22261 {
22262 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
22263 }
22264 {
22265 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
22266 }
22267 {
22268 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
22269 }
22270 {
22271 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
22272 }
22273 {
22274 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
22275 }
22276 {
22277 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
22278 }
22279 {
22280 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
22281 }
22282 {
22283 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
22284 }
22285 {
22286 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
22287 }
22288 {
22289 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
22290 }
22291 {
22292 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
22293 }
22294 {
22295 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
22296 }
22297 {
22298 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
22299 }
22300 {
22301 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
22302 }
22303 {
22304 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
22305 }
22306 {
22307 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
22308 }
22309 {
22310 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
22311 }
22312 {
22313 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
22314 }
22315 {
22316 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
22317 }
22318 {
22319 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
22320 }
22321 {
22322 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
22323 }
22324 {
22325 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
22326 }
22327 {
22328 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
22329 }
22330 {
22331 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
22332 }
22333 {
22334 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
22335 }
22336 {
22337 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
22338 }
22339 {
22340 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
22341 }
22342 {
22343 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
22344 }
22345 {
22346 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
22347 }
22348 {
22349 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
22350 }
22351 {
22352 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
22353 }
22354 {
22355 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
22356 }
22357 {
22358 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
22359 }
22360 {
22361 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
22362 }
22363 {
22364 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
22365 }
22366 {
22367 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
22368 }
22369 {
22370 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
22371 }
22372 {
22373 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
22374 }
22375
22376 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
22377
22378 {
22379 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
22380 }
22381 {
22382 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
22383 }
22384 {
22385 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
22386 }
22387 {
22388 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
22389 }
22390 {
22391 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
22392 }
22393 {
22394 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
22395 }
22396 {
22397 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
22398 }
22399 {
22400 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
22401 }
22402 {
22403 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
22404 }
22405 {
22406 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
22407 }
22408 {
22409 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
22410 }
22411 {
22412 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
22413 }
22414 {
22415 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
22416 }
22417 {
22418 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
22419 }
22420 {
22421 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
22422 }
22423 {
22424 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
22425 }
22426 {
22427 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
22428 }
22429 {
22430 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
22431 }
22432 {
22433 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
22434 }
22435 {
22436 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
22437 }
22438 {
22439 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
22440 }
22441 {
22442 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
22443 }
22444 {
22445 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
22446 }
22447 {
22448 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
22449 }
22450 {
22451 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
22452 }
22453 {
22454 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
22455 }
22456 {
22457 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
22458 }
22459 {
22460 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
22461 }
22462 {
22463 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
22464 }
22465 {
22466 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
22467 }
22468 {
22469 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
22470 }
22471 {
22472 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
22473 }
22474 {
22475 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
22476 }
22477 {
22478 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
22479 }
22480 {
22481 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
22482 }
22483 {
22484 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
22485 }
22486 {
22487 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
22488 }
22489 {
22490 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
22491 }
22492 {
22493 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
22494 }
22495 {
22496 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
22497 }
22498 {
22499 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
22500 }
22501 {
22502 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
22503 }
22504 {
22505 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
22506 }
22507 {
22508 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
22509 }
22510 {
22511 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
22512 }
22513 {
22514 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
22515 }
22516 {
22517 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
22518 }
22519 {
22520 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
22521 }
22522 {
22523 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
22524 }
22525 {
22526 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
22527 }
22528 {
22529 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
22530 }
22531 {
22532 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
22533 }
22534 {
22535 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
22536 }
22537 {
22538 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
22539 }
22540 {
22541 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
22542 }
22543 {
22544 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
22545 }
22546 {
22547 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
22548 }
22549 {
22550 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
22551 }
22552 {
22553 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
22554 }
22555 {
22556 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
22557 }
22558 {
22559 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
22560 }
22561 {
22562 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
22563 }
22564 {
22565 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
22566 }
22567 {
22568 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
22569 }
22570 {
22571 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
22572 }
22573 {
22574 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
22575 }
22576 {
22577 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
22578 }
22579 {
22580 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
22581 }
22582 {
22583 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
22584 }
22585 {
22586 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
22587 }
22588 {
22589 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
22590 }
22591 {
22592 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
22593 }
22594 {
22595 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
22596 }
22597 {
22598 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
22599 }
22600 {
22601 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
22602 }
22603 {
22604 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
22605 }
22606 {
22607 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
22608 }
22609 {
22610 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
22611 }
22612 {
22613 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
22614 }
22615 {
22616 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
22617 }
22618 {
22619 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
22620 }
22621 {
22622 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
22623 }
22624 {
22625 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
22626 }
22627 {
22628 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
22629 }
22630 {
22631 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
22632 }
22633 {
22634 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
22635 }
22636 {
22637 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
22638 }
22639 {
22640 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
22641 }
22642 {
22643 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
22644 }
22645 {
22646 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
22647 }
22648 {
22649 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
22650 }
22651 {
22652 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
22653 }
22654 {
22655 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
22656 }
22657 {
22658 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
22659 }
22660 {
22661 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
22662 }
22663 {
22664 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
22665 }
22666 {
22667 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
22668 }
22669 {
22670 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
22671 }
22672 {
22673 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
22674 }
22675 {
22676 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
22677 }
22678 {
22679 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
22680 }
22681 {
22682 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
22683 }
22684 {
22685 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
22686 }
22687 {
22688 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
22689 }
22690 {
22691 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
22692 }
22693 {
22694 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
22695 }
22696 {
22697 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
22698 }
22699 {
22700 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
22701 }
22702 {
22703 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
22704 }
22705 {
22706 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
22707 }
22708 {
22709 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
22710 }
22711 {
22712 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
22713 }
22714 {
22715 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
22716 }
22717 {
22718 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
22719 }
22720 {
22721 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
22722 }
22723 {
22724 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
22725 }
22726 {
22727 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
22728 }
22729 {
22730 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
22731 }
22732 {
22733 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
22734 }
22735 {
22736 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
22737 }
22738 {
22739 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
22740 }
22741 {
22742 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
22743 }
22744 {
22745 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
22746 }
22747 {
22748 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
22749 }
22750 {
22751 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
22752 }
22753 {
22754 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
22755 }
22756 {
22757 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
22758 }
22759 {
22760 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
22761 }
22762 {
22763 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
22764 }
22765 {
22766 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
22767 }
22768 {
22769 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
22770 }
22771 {
22772 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
22773 }
22774 {
22775 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
22776 }
22777 {
22778 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
22779 }
22780 {
22781 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
22782 }
22783 {
22784 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
22785 }
22786 {
22787 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
22788 }
22789 {
22790 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
22791 }
22792 {
22793 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
22794 }
22795 {
22796 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
22797 }
22798 {
22799 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
22800 }
22801 {
22802 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
22803 }
22804 {
22805 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
22806 }
22807 {
22808 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
22809 }
22810 {
22811 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
22812 }
22813 {
22814 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
22815 }
22816 {
22817 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
22818 }
22819 {
22820 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
22821 }
22822 {
22823 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
22824 }
22825 {
22826 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
22827 }
22828 {
22829 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
22830 }
22831 {
22832 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
22833 }
22834 {
22835 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
22836 }
22837 {
22838 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
22839 }
22840 {
22841 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
22842 }
22843 {
22844 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
22845 }
22846 {
22847 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
22848 }
22849 {
22850 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
22851 }
22852 {
22853 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
22854 }
22855 {
22856 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
22857 }
22858 {
22859 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
22860 }
22861 {
22862 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
22863 }
22864 {
22865 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
22866 }
22867 {
22868 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
22869 }
22870 {
22871 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
22872 }
22873 {
22874 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
22875 }
22876 {
22877 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
22878 }
22879 {
22880 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
22881 }
22882 {
22883 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
22884 }
22885 {
22886 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
22887 }
22888 {
22889 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
22890 }
22891 {
22892 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
22893 }
22894 {
22895 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
22896 }
22897 {
22898 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
22899 }
22900 {
22901 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
22902 }
22903 {
22904 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
22905 }
22906 {
22907 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
22908 }
22909 {
22910 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
22911 }
22912 {
22913 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
22914 }
22915 {
22916 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
22917 }
22918 {
22919 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
22920 }
22921 {
22922 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
22923 }
22924 {
22925 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
22926 }
22927 {
22928 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
22929 }
22930 {
22931 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
22932 }
22933 {
22934 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
22935 }
22936 {
22937 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
22938 }
22939 {
22940 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
22941 }
22942 {
22943 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
22944 }
22945 {
22946 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
22947 }
22948 {
22949 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
22950 }
22951 {
22952 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
22953 }
22954 {
22955 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
22956 }
22957 {
22958 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
22959 }
22960 {
22961 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
22962 }
22963 {
22964 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
22965 }
22966 {
22967 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
22968 }
22969 {
22970 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
22971 }
22972 {
22973 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
22974 }
22975 {
22976 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
22977 }
22978 {
22979 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
22980 }
22981 {
22982 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
22983 }
22984 {
22985 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
22986 }
22987 {
22988 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
22989 }
22990 {
22991 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
22992 }
22993 {
22994 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
22995 }
22996 {
22997 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
22998 }
22999 {
23000 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
23001 }
23002 {
23003 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
23004 }
23005 {
23006 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
23007 }
23008 {
23009 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
23010 }
23011 {
23012 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
23013 }
23014 {
23015 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
23016 }
23017 {
23018 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
23019 }
23020 {
23021 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
23022 }
23023 {
23024 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
23025 }
23026 {
23027 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
23028 }
23029 {
23030 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
23031 }
23032 {
23033 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
23034 }
23035 {
23036 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
23037 }
23038 {
23039 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
23040 }
23041 {
23042 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
23043 }
23044 {
23045 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
23046 }
23047 {
23048 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
23049 }
23050 {
23051 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
23052 }
23053 {
23054 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
23055 }
23056 {
23057 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
23058 }
23059 {
23060 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
23061 }
23062 {
23063 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
23064 }
23065 {
23066 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
23067 }
23068 {
23069 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
23070 }
23071 {
23072 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
23073 }
23074 {
23075 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
23076 }
23077 {
23078 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
23079 }
23080 {
23081 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
23082 }
23083 {
23084 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
23085 }
23086 {
23087 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
23088 }
23089 {
23090 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
23091 }
23092 {
23093 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
23094 }
23095 {
23096 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
23097 }
23098 {
23099 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
23100 }
23101 {
23102 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
23103 }
23104 {
23105 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
23106 }
23107 {
23108 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
23109 }
23110 {
23111 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
23112 }
23113 {
23114 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
23115 }
23116 {
23117 PyDict_SetItemString(d,"BUFFER_VIRTUAL_AREA", SWIG_From_int((int)(wxBUFFER_VIRTUAL_AREA)));
23118 }
23119 {
23120 PyDict_SetItemString(d,"BUFFER_CLIENT_AREA", SWIG_From_int((int)(wxBUFFER_CLIENT_AREA)));
23121 }
23122 {
23123 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
23124 }
23125 {
23126 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
23127 }
23128 {
23129 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
23130 }
23131 {
23132 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
23133 }
23134 {
23135 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
23136 }
23137 {
23138 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
23139 }
23140 {
23141 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
23142 }
23143 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
23144 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
23145 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
23146 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
23147 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
23148 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
23149 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
23150 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
23151 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
23152 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
23153 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
23154 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
23155 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
23156 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
23157 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
23158 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
23159 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
23160 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
23161 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
23162 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
23163 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
23164 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
23165 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
23166 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
23167 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
23168 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
23169 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
23170 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
23171 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
23172 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
23173 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
23174 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
23175 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
23176 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
23177 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
23178 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
23179 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
23180 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
23181 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
23182 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
23183 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
23184 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
23185 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
23186 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
23187 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
23188 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
23189 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
23190
23191 // Work around a chicken/egg problem in drawlist.cpp
23192 wxPyDrawList_SetAPIPtr();
23193
23194 }
23195
wxWidgets (Impactor)