]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_gdi_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Applied patch [ 1232933 ] [WinCE] wxDateTime incorrect reading
[wxWidgets.git] / wxPython / src / mac / _gdi_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxPostScriptDC swig_types[0]
1343 #define SWIGTYPE_p_wxBrush swig_types[1]
1344 #define SWIGTYPE_p_wxColour swig_types[2]
1345 #define SWIGTYPE_p_wxDC swig_types[3]
1346 #define SWIGTYPE_p_wxMirrorDC swig_types[4]
1347 #define SWIGTYPE_p_form_ops_t swig_types[5]
1348 #define SWIGTYPE_p_wxRendererVersion swig_types[6]
1349 #define SWIGTYPE_p_wxDuplexMode swig_types[7]
1350 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[8]
1351 #define SWIGTYPE_p_char swig_types[9]
1352 #define SWIGTYPE_p_wxIconLocation swig_types[10]
1353 #define SWIGTYPE_p_wxImage swig_types[11]
1354 #define SWIGTYPE_p_wxMetaFileDC swig_types[12]
1355 #define SWIGTYPE_p_wxMask swig_types[13]
1356 #define SWIGTYPE_p_wxSize swig_types[14]
1357 #define SWIGTYPE_p_wxFont swig_types[15]
1358 #define SWIGTYPE_p_wxWindow swig_types[16]
1359 #define SWIGTYPE_p_double swig_types[17]
1360 #define SWIGTYPE_p_wxMemoryDC swig_types[18]
1361 #define SWIGTYPE_p_wxFontMapper swig_types[19]
1362 #define SWIGTYPE_p_wxEffects swig_types[20]
1363 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[21]
1364 #define SWIGTYPE_p_wxPalette swig_types[22]
1365 #define SWIGTYPE_p_wxBitmap swig_types[23]
1366 #define SWIGTYPE_p_wxObject swig_types[24]
1367 #define SWIGTYPE_p_wxRegionIterator swig_types[25]
1368 #define SWIGTYPE_p_wxRect swig_types[26]
1369 #define SWIGTYPE_p_wxPaperSize swig_types[27]
1370 #define SWIGTYPE_p_wxString swig_types[28]
1371 #define SWIGTYPE_unsigned_int swig_types[29]
1372 #define SWIGTYPE_p_unsigned_int swig_types[30]
1373 #define SWIGTYPE_p_wxPrinterDC swig_types[31]
1374 #define SWIGTYPE_p_wxIconBundle swig_types[32]
1375 #define SWIGTYPE_p_wxPoint swig_types[33]
1376 #define SWIGTYPE_p_wxDash swig_types[34]
1377 #define SWIGTYPE_p_wxScreenDC swig_types[35]
1378 #define SWIGTYPE_p_wxCursor swig_types[36]
1379 #define SWIGTYPE_p_wxClientDC swig_types[37]
1380 #define SWIGTYPE_p_wxBufferedDC swig_types[38]
1381 #define SWIGTYPE_p_wxImageList swig_types[39]
1382 #define SWIGTYPE_p_unsigned_char swig_types[40]
1383 #define SWIGTYPE_p_wxGDIObject swig_types[41]
1384 #define SWIGTYPE_p_wxIcon swig_types[42]
1385 #define SWIGTYPE_p_wxLocale swig_types[43]
1386 #define SWIGTYPE_ptrdiff_t swig_types[44]
1387 #define SWIGTYPE_std__ptrdiff_t swig_types[45]
1388 #define SWIGTYPE_p_wxRegion swig_types[46]
1389 #define SWIGTYPE_p_wxConfigBase swig_types[47]
1390 #define SWIGTYPE_p_wxLanguageInfo swig_types[48]
1391 #define SWIGTYPE_p_wxWindowDC swig_types[49]
1392 #define SWIGTYPE_p_wxPrintData swig_types[50]
1393 #define SWIGTYPE_p_wxBrushList swig_types[51]
1394 #define SWIGTYPE_p_wxFontList swig_types[52]
1395 #define SWIGTYPE_p_wxPen swig_types[53]
1396 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[54]
1397 #define SWIGTYPE_p_wxPaintDC swig_types[55]
1398 #define SWIGTYPE_p_wxPenList swig_types[56]
1399 #define SWIGTYPE_p_int swig_types[57]
1400 #define SWIGTYPE_p_wxMetaFile swig_types[58]
1401 #define SWIGTYPE_p_wxRendererNative swig_types[59]
1402 #define SWIGTYPE_p_unsigned_long swig_types[60]
1403 #define SWIGTYPE_p_wxNativeFontInfo swig_types[61]
1404 #define SWIGTYPE_p_wxEncodingConverter swig_types[62]
1405 #define SWIGTYPE_p_wxSplitterRenderParams swig_types[63]
1406 #define SWIGTYPE_p_wxColourDatabase swig_types[64]
1407 static swig_type_info *swig_types[66];
1408
1409 /* -------- TYPES TABLE (END) -------- */
1410
1411
1412 /*-----------------------------------------------
1413 @(target):= _gdi_.so
1414 ------------------------------------------------*/
1415 #define SWIG_init init_gdi_
1416
1417 #define SWIG_name "_gdi_"
1418
1419 #include "wx/wxPython/wxPython.h"
1420 #include "wx/wxPython/pyclasses.h"
1421
1422
1423 static const wxString wxPyEmptyString(wxEmptyString);
1424
1425 #include <limits.h>
1426
1427
1428 SWIGINTERN int
1429 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1430 const char *errmsg)
1431 {
1432 if (value < min_value) {
1433 if (errmsg) {
1434 PyErr_Format(PyExc_OverflowError,
1435 "value %ld is less than '%s' minimum %ld",
1436 value, errmsg, min_value);
1437 }
1438 return 0;
1439 } else if (value > max_value) {
1440 if (errmsg) {
1441 PyErr_Format(PyExc_OverflowError,
1442 "value %ld is greater than '%s' maximum %ld",
1443 value, errmsg, max_value);
1444 }
1445 return 0;
1446 }
1447 return 1;
1448 }
1449
1450
1451 SWIGINTERN int
1452 SWIG_AsVal_long(PyObject* obj, long* val)
1453 {
1454 if (PyNumber_Check(obj)) {
1455 if (val) *val = PyInt_AsLong(obj);
1456 return 1;
1457 }
1458 else {
1459 SWIG_type_error("number", obj);
1460 }
1461 return 0;
1462 }
1463
1464
1465 #if INT_MAX != LONG_MAX
1466 SWIGINTERN int
1467 SWIG_AsVal_int(PyObject *obj, int *val)
1468 {
1469 const char* errmsg = val ? "int" : (char*)0;
1470 long v;
1471 if (SWIG_AsVal_long(obj, &v)) {
1472 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1473 if (val) *val = (int)(v);
1474 return 1;
1475 } else {
1476 return 0;
1477 }
1478 } else {
1479 PyErr_Clear();
1480 }
1481 if (val) {
1482 SWIG_type_error(errmsg, obj);
1483 }
1484 return 0;
1485 }
1486 #else
1487 SWIGINTERNSHORT int
1488 SWIG_AsVal_int(PyObject *obj, int *val)
1489 {
1490 return SWIG_AsVal_long(obj,(long*)val);
1491 }
1492 #endif
1493
1494
1495 SWIGINTERN int
1496 SWIG_AsVal_bool(PyObject *obj, bool *val)
1497 {
1498 if (obj == Py_True) {
1499 if (val) *val = true;
1500 return 1;
1501 }
1502 if (obj == Py_False) {
1503 if (val) *val = false;
1504 return 1;
1505 }
1506 int res = 0;
1507 if (SWIG_AsVal_int(obj, &res)) {
1508 if (val) *val = res ? true : false;
1509 return 1;
1510 } else {
1511 PyErr_Clear();
1512 }
1513 if (val) {
1514 SWIG_type_error("bool", obj);
1515 }
1516 return 0;
1517 }
1518
1519
1520 SWIGINTERNSHORT bool
1521 SWIG_As_bool(PyObject* obj)
1522 {
1523 bool v;
1524 if (!SWIG_AsVal_bool(obj, &v)) {
1525 /*
1526 this is needed to make valgrind/purify happier.
1527 */
1528 memset((void*)&v, 0, sizeof(bool));
1529 }
1530 return v;
1531 }
1532
1533
1534 SWIGINTERNSHORT int
1535 SWIG_Check_bool(PyObject* obj)
1536 {
1537 return SWIG_AsVal_bool(obj, (bool*)0);
1538 }
1539
1540
1541 SWIGINTERN int
1542 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1543 {
1544 long v = 0;
1545 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1546 SWIG_type_error("unsigned number", obj);
1547 }
1548 else if (val)
1549 *val = (unsigned long)v;
1550 return 1;
1551 }
1552
1553
1554 SWIGINTERNSHORT int
1555 SWIG_CheckUnsignedLongInRange(unsigned long value,
1556 unsigned long max_value,
1557 const char *errmsg)
1558 {
1559 if (value > max_value) {
1560 if (errmsg) {
1561 PyErr_Format(PyExc_OverflowError,
1562 "value %lu is greater than '%s' minimum %lu",
1563 value, errmsg, max_value);
1564 }
1565 return 0;
1566 }
1567 return 1;
1568 }
1569
1570
1571 SWIGINTERN int
1572 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1573 {
1574 const char* errmsg = val ? "unsigned char" : (char*)0;
1575 unsigned long v;
1576 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1577 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1578 if (val) *val = (unsigned char)(v);
1579 return 1;
1580 } else {
1581 return 0;
1582 }
1583 } else {
1584 PyErr_Clear();
1585 }
1586 if (val) {
1587 SWIG_type_error(errmsg, obj);
1588 }
1589 return 0;
1590 }
1591
1592
1593 SWIGINTERNSHORT unsigned char
1594 SWIG_As_unsigned_SS_char(PyObject* obj)
1595 {
1596 unsigned char v;
1597 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1598 /*
1599 this is needed to make valgrind/purify happier.
1600 */
1601 memset((void*)&v, 0, sizeof(unsigned char));
1602 }
1603 return v;
1604 }
1605
1606
1607 SWIGINTERNSHORT int
1608 SWIG_Check_unsigned_SS_char(PyObject* obj)
1609 {
1610 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1611 }
1612
1613
1614 SWIGINTERNSHORT unsigned long
1615 SWIG_As_unsigned_SS_long(PyObject* obj)
1616 {
1617 unsigned long v;
1618 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1619 /*
1620 this is needed to make valgrind/purify happier.
1621 */
1622 memset((void*)&v, 0, sizeof(unsigned long));
1623 }
1624 return v;
1625 }
1626
1627
1628 SWIGINTERNSHORT int
1629 SWIG_Check_unsigned_SS_long(PyObject* obj)
1630 {
1631 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1632 }
1633
1634
1635 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1636 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1637 /*@@*/
1638
1639
1640 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1641 #define SWIG_From_long PyInt_FromLong
1642 /*@@*/
1643
1644 static PyObject *wxColour_Get(wxColour *self){
1645 PyObject* rv = PyTuple_New(3);
1646 int red = -1;
1647 int green = -1;
1648 int blue = -1;
1649 if (self->Ok()) {
1650 red = self->Red();
1651 green = self->Green();
1652 blue = self->Blue();
1653 }
1654 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1655 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1656 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1657 return rv;
1658 }
1659 static unsigned long wxColour_GetRGB(wxColour *self){
1660 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1661 }
1662
1663 SWIGINTERNSHORT PyObject*
1664 SWIG_From_unsigned_SS_long(unsigned long value)
1665 {
1666 return (value > LONG_MAX) ?
1667 PyLong_FromUnsignedLong(value)
1668 : PyInt_FromLong((long)(value));
1669 }
1670
1671
1672 SWIGINTERNSHORT int
1673 SWIG_As_int(PyObject* obj)
1674 {
1675 int v;
1676 if (!SWIG_AsVal_int(obj, &v)) {
1677 /*
1678 this is needed to make valgrind/purify happier.
1679 */
1680 memset((void*)&v, 0, sizeof(int));
1681 }
1682 return v;
1683 }
1684
1685
1686 SWIGINTERNSHORT int
1687 SWIG_Check_int(PyObject* obj)
1688 {
1689 return SWIG_AsVal_int(obj, (int*)0);
1690 }
1691
1692
1693 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1694 #define SWIG_From_int PyInt_FromLong
1695 /*@@*/
1696
1697
1698 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1699 PyObject* o2;
1700 PyObject* o3;
1701
1702 if (!target) {
1703 target = o;
1704 } else if (target == Py_None) {
1705 Py_DECREF(Py_None);
1706 target = o;
1707 } else {
1708 if (!PyTuple_Check(target)) {
1709 o2 = target;
1710 target = PyTuple_New(1);
1711 PyTuple_SetItem(target, 0, o2);
1712 }
1713 o3 = PyTuple_New(1);
1714 PyTuple_SetItem(o3, 0, o);
1715
1716 o2 = target;
1717 target = PySequence_Concat(o2, o3);
1718 Py_DECREF(o2);
1719 Py_DECREF(o3);
1720 }
1721 return target;
1722 }
1723
1724
1725 static PyObject *wxPen_GetDashes(wxPen *self){
1726 wxDash* dashes;
1727 int count = self->GetDashes(&dashes);
1728 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1729 PyObject* retval = PyList_New(0);
1730 for (int x=0; x<count; x++) {
1731 PyObject* pyint = PyInt_FromLong(dashes[x]);
1732 PyList_Append(retval, pyint);
1733 Py_DECREF(pyint);
1734 }
1735 wxPyEndBlockThreads(blocked);
1736 return retval;
1737 }
1738 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1739 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1740 int size = PyList_Size(pyDashes);
1741 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1742
1743 // black magic warning! The array of wxDashes needs to exist as
1744 // long as the pen does because wxPen does not copy the array. So
1745 // stick a copy in a Python string object and attach it to _self,
1746 // and then call SetDashes with a pointer to that array. Then
1747 // when the Python pen object is destroyed the array will be
1748 // cleaned up too.
1749 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1750 PyObject_SetAttrString(_self, "_dashes", strDashes);
1751
1752 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1753 delete [] dashes;
1754 Py_DECREF(strDashes);
1755 wxPyEndBlockThreads(blocked);
1756 }
1757 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1758 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1759
1760 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1761 #define SWIG_From_short PyInt_FromLong
1762 /*@@*/
1763
1764
1765 SWIGINTERN int
1766 SWIG_AsVal_short(PyObject *obj, short *val)
1767 {
1768 const char* errmsg = val ? "short" : (char*)0;
1769 long v;
1770 if (SWIG_AsVal_long(obj, &v)) {
1771 if (SWIG_CheckLongInRange(v, SHRT_MIN, SHRT_MAX, errmsg)) {
1772 if (val) *val = (short)(v);
1773 return 1;
1774 } else {
1775 return 0;
1776 }
1777 } else {
1778 PyErr_Clear();
1779 }
1780 if (val) {
1781 SWIG_type_error(errmsg, obj);
1782 }
1783 return 0;
1784 }
1785
1786
1787 SWIGINTERNSHORT short
1788 SWIG_As_short(PyObject* obj)
1789 {
1790 short v;
1791 if (!SWIG_AsVal_short(obj, &v)) {
1792 /*
1793 this is needed to make valgrind/purify happier.
1794 */
1795 memset((void*)&v, 0, sizeof(short));
1796 }
1797 return v;
1798 }
1799
1800
1801 SWIGINTERNSHORT int
1802 SWIG_Check_short(PyObject* obj)
1803 {
1804 return SWIG_AsVal_short(obj, (short*)0);
1805 }
1806
1807
1808 #include <wx/image.h>
1809
1810 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1811 char** cArray = NULL;
1812 int count;
1813
1814 if (!PyList_Check(listOfStrings)) {
1815 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1816 return NULL;
1817 }
1818 count = PyList_Size(listOfStrings);
1819 cArray = new char*[count];
1820
1821 for(int x=0; x<count; x++) {
1822 // TODO: Need some validation and error checking here
1823 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1824 }
1825 return cArray;
1826 }
1827
1828
1829 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1830 char** cArray = NULL;
1831 wxBitmap* bmp;
1832
1833 cArray = ConvertListOfStrings(listOfStrings);
1834 if (! cArray)
1835 return NULL;
1836 bmp = new wxBitmap(cArray);
1837 delete [] cArray;
1838 return bmp;
1839 }
1840 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1841 char* buf;
1842 int length;
1843 PyString_AsStringAndSize(bits, &buf, &length);
1844 return new wxBitmap(buf, width, height, depth);
1845 }
1846 static wxSize wxBitmap_GetSize(wxBitmap *self){
1847 wxSize size(self->GetWidth(), self->GetHeight());
1848 return size;
1849 }
1850 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1851 wxMask *mask = new wxMask(*self, colour);
1852 self->SetMask(mask);
1853 }
1854 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1855 self->SetWidth(size.x);
1856 self->SetHeight(size.y);
1857 }
1858 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1859 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1860 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1861 if ( !colour.Ok() )
1862 return new wxMask(bitmap, *wxBLACK);
1863 else
1864 return new wxMask(bitmap, colour);
1865 }
1866
1867 #include <wx/iconbndl.h>
1868
1869 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1870 wxIcon* icon = new wxIcon();
1871 icon->CopyFromBitmap(bmp);
1872 return icon;
1873 }
1874 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1875 char** cArray = NULL;
1876 wxIcon* icon;
1877
1878 cArray = ConvertListOfStrings(listOfStrings);
1879 if (! cArray)
1880 return NULL;
1881 icon = new wxIcon(cArray);
1882 delete [] cArray;
1883 return icon;
1884 }
1885 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1886
1887
1888
1889 return new wxIconLocation(*filename);
1890
1891 }
1892 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1893
1894
1895
1896 // do nothing
1897
1898 }
1899 static int wxIconLocation_GetIndex(wxIconLocation *self){
1900
1901
1902
1903 return -1;
1904
1905 }
1906
1907 SWIGINTERNSHORT long
1908 SWIG_As_long(PyObject* obj)
1909 {
1910 long v;
1911 if (!SWIG_AsVal_long(obj, &v)) {
1912 /*
1913 this is needed to make valgrind/purify happier.
1914 */
1915 memset((void*)&v, 0, sizeof(long));
1916 }
1917 return v;
1918 }
1919
1920
1921 SWIGINTERNSHORT int
1922 SWIG_Check_long(PyObject* obj)
1923 {
1924 return SWIG_AsVal_long(obj, (long*)0);
1925 }
1926
1927 static wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1928 #ifdef __WXGTK__
1929 wxImage img(cursorName, type);
1930 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
1931 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
1932 return new wxCursor(img);
1933 #else
1934 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
1935 #endif
1936 }
1937
1938
1939 static void wxRegionIterator_Next(wxRegionIterator *self){
1940 (*self) ++;
1941 }
1942 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1943 return self->operator bool();
1944 }
1945
1946 #include <wx/fontutil.h>
1947 #include <wx/fontmap.h>
1948 #include <wx/fontenum.h>
1949
1950 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1951 return self->ToString();
1952 }
1953
1954 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
1955 static wxNativeEncodingInfo info;
1956 if ( wxGetNativeFontEncoding(encoding, &info) )
1957 return &info;
1958 else
1959 return NULL;
1960 }
1961
1962 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1963 wxFontEncoding alt_enc;
1964 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1965 return PyInt_FromLong(alt_enc);
1966 else {
1967 Py_INCREF(Py_None);
1968 return Py_None;
1969 }
1970 }
1971 static wxFont *new_wxFont(wxString const &info){
1972 wxNativeFontInfo nfi;
1973 nfi.FromString(info);
1974 return new wxFont(nfi);
1975 }
1976 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1977 return wxFont::New(pointSize, family, flags, face, encoding);
1978 }
1979 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1980 return wxFontBase::New(pixelSize, family,
1981 style, weight, underlined,
1982 face, encoding);
1983 }
1984 static wxFont *new_wxFont(wxSize const &pixelSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1985 return wxFontBase::New(pixelSize, family, flags, face, encoding);
1986 }
1987 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1988 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1989
1990 class wxPyFontEnumerator : public wxFontEnumerator {
1991 public:
1992 wxPyFontEnumerator() {}
1993 ~wxPyFontEnumerator() {}
1994
1995 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1996 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1997
1998 PYPRIVATE;
1999 };
2000
2001 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
2002 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
2003
2004
2005 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
2006 wxArrayString* arr = self->GetEncodings();
2007 if (arr)
2008 return wxArrayString2PyList_helper(*arr);
2009 else
2010 return PyList_New(0);
2011 }
2012 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
2013 wxArrayString* arr = self->GetFacenames();
2014 if (arr)
2015 return wxArrayString2PyList_helper(*arr);
2016 else
2017 return PyList_New(0);
2018 }
2019
2020 #include <locale.h>
2021
2022 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
2023 wxLocale* loc;
2024 if (language == -1)
2025 loc = new wxLocale();
2026 else
2027 loc = new wxLocale(language, flags);
2028 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2029 // for the floating point conversions and such to work right.
2030 #if PY_VERSION_HEX < 0x02040000
2031 setlocale(LC_NUMERIC, "C");
2032 #endif
2033 return loc;
2034 }
2035 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
2036 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
2037 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2038 // for the floating point conversions and such to work right.
2039 #if PY_VERSION_HEX < 0x02040000
2040 setlocale(LC_NUMERIC, "C");
2041 #endif
2042 return rc;
2043 }
2044 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
2045 bool rc = self->Init(language, flags);
2046 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2047 // for the floating point conversions and such to work right.
2048 #if PY_VERSION_HEX < 0x02040000
2049 setlocale(LC_NUMERIC, "C");
2050 #endif
2051 return rc;
2052 }
2053
2054 #include "wx/wxPython/pydrawxxx.h"
2055
2056 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2057 wxColour col;
2058 self->GetPixel(x, y, &col);
2059 return col;
2060 }
2061 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2062 wxColour col;
2063 self->GetPixel(pt, &col);
2064 return col;
2065 }
2066
2067 SWIGINTERN int
2068 SWIG_AsVal_double(PyObject *obj, double* val)
2069 {
2070 if (PyNumber_Check(obj)) {
2071 if (val) *val = PyFloat_AsDouble(obj);
2072 return 1;
2073 }
2074 else {
2075 SWIG_type_error("number", obj);
2076 }
2077 return 0;
2078 }
2079
2080
2081 SWIGINTERNSHORT double
2082 SWIG_As_double(PyObject* obj)
2083 {
2084 double v;
2085 if (!SWIG_AsVal_double(obj, &v)) {
2086 /*
2087 this is needed to make valgrind/purify happier.
2088 */
2089 memset((void*)&v, 0, sizeof(double));
2090 }
2091 return v;
2092 }
2093
2094
2095 SWIGINTERNSHORT int
2096 SWIG_Check_double(PyObject* obj)
2097 {
2098 return SWIG_AsVal_double(obj, (double*)0);
2099 }
2100
2101 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2102 wxRect rv;
2103 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2104 return rv;
2105 }
2106
2107 static wxRect wxDC_GetClippingRect(wxDC *self){
2108 wxRect rect;
2109 self->GetClippingBox(rect);
2110 return rect;
2111 }
2112 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2113 wxArrayInt widths;
2114 self->GetPartialTextExtents(text, widths);
2115 return widths;
2116 }
2117
2118 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2119 #define SWIG_From_double PyFloat_FromDouble
2120 /*@@*/
2121
2122
2123 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2124 self->SetLogicalOrigin(point.x, point.y);
2125 }
2126 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2127 self->SetDeviceOrigin(point.x, point.y);
2128 }
2129 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2130 self->CalcBoundingBox(point.x, point.y);
2131 }
2132 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2133 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2134 }
2135 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2136 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2137 }
2138 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2139 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2140 }
2141 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2142 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2143 }
2144 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2145 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2146 }
2147 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2148 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2149 }
2150
2151 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2152 *x1 = dc->MinX();
2153 *y1 = dc->MinY();
2154 *x2 = dc->MaxX();
2155 *y2 = dc->MaxY();
2156 }
2157
2158
2159 #include <wx/dcbuffer.h>
2160
2161
2162 #include <wx/dcps.h>
2163
2164
2165 #include <wx/metafile.h>
2166
2167
2168
2169 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2170 self->AddColour(name, wxColour(red, green, blue));
2171 }
2172
2173 #include <wx/effects.h>
2174
2175
2176 #include "wx/renderer.h"
2177
2178
2179 SWIGINTERNSHORT PyObject*
2180 SWIG_From_bool(bool value)
2181 {
2182 PyObject *obj = value ? Py_True : Py_False;
2183 Py_INCREF(obj);
2184 return obj;
2185 }
2186
2187 #ifdef __cplusplus
2188 extern "C" {
2189 #endif
2190 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2191 PyObject *resultobj;
2192 wxGDIObject *result;
2193 char *kwnames[] = {
2194 NULL
2195 };
2196
2197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2198 {
2199 if (!wxPyCheckForApp()) SWIG_fail;
2200 PyThreadState* __tstate = wxPyBeginAllowThreads();
2201 result = (wxGDIObject *)new wxGDIObject();
2202
2203 wxPyEndAllowThreads(__tstate);
2204 if (PyErr_Occurred()) SWIG_fail;
2205 }
2206 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2207 return resultobj;
2208 fail:
2209 return NULL;
2210 }
2211
2212
2213 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2214 PyObject *resultobj;
2215 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2216 PyObject * obj0 = 0 ;
2217 char *kwnames[] = {
2218 (char *) "self", NULL
2219 };
2220
2221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2223 if (SWIG_arg_fail(1)) SWIG_fail;
2224 {
2225 PyThreadState* __tstate = wxPyBeginAllowThreads();
2226 delete arg1;
2227
2228 wxPyEndAllowThreads(__tstate);
2229 if (PyErr_Occurred()) SWIG_fail;
2230 }
2231 Py_INCREF(Py_None); resultobj = Py_None;
2232 return resultobj;
2233 fail:
2234 return NULL;
2235 }
2236
2237
2238 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2239 PyObject *resultobj;
2240 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2241 bool result;
2242 PyObject * obj0 = 0 ;
2243 char *kwnames[] = {
2244 (char *) "self", NULL
2245 };
2246
2247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2249 if (SWIG_arg_fail(1)) SWIG_fail;
2250 {
2251 PyThreadState* __tstate = wxPyBeginAllowThreads();
2252 result = (bool)(arg1)->GetVisible();
2253
2254 wxPyEndAllowThreads(__tstate);
2255 if (PyErr_Occurred()) SWIG_fail;
2256 }
2257 {
2258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2259 }
2260 return resultobj;
2261 fail:
2262 return NULL;
2263 }
2264
2265
2266 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2267 PyObject *resultobj;
2268 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2269 bool arg2 ;
2270 PyObject * obj0 = 0 ;
2271 PyObject * obj1 = 0 ;
2272 char *kwnames[] = {
2273 (char *) "self",(char *) "visible", NULL
2274 };
2275
2276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2278 if (SWIG_arg_fail(1)) SWIG_fail;
2279 {
2280 arg2 = (bool)(SWIG_As_bool(obj1));
2281 if (SWIG_arg_fail(2)) SWIG_fail;
2282 }
2283 {
2284 PyThreadState* __tstate = wxPyBeginAllowThreads();
2285 (arg1)->SetVisible(arg2);
2286
2287 wxPyEndAllowThreads(__tstate);
2288 if (PyErr_Occurred()) SWIG_fail;
2289 }
2290 Py_INCREF(Py_None); resultobj = Py_None;
2291 return resultobj;
2292 fail:
2293 return NULL;
2294 }
2295
2296
2297 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2298 PyObject *resultobj;
2299 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2300 bool result;
2301 PyObject * obj0 = 0 ;
2302 char *kwnames[] = {
2303 (char *) "self", NULL
2304 };
2305
2306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2308 if (SWIG_arg_fail(1)) SWIG_fail;
2309 {
2310 PyThreadState* __tstate = wxPyBeginAllowThreads();
2311 result = (bool)(arg1)->IsNull();
2312
2313 wxPyEndAllowThreads(__tstate);
2314 if (PyErr_Occurred()) SWIG_fail;
2315 }
2316 {
2317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2318 }
2319 return resultobj;
2320 fail:
2321 return NULL;
2322 }
2323
2324
2325 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2326 PyObject *obj;
2327 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2328 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2329 Py_INCREF(obj);
2330 return Py_BuildValue((char *)"");
2331 }
2332 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2333 PyObject *resultobj;
2334 byte arg1 = (byte) 0 ;
2335 byte arg2 = (byte) 0 ;
2336 byte arg3 = (byte) 0 ;
2337 wxColour *result;
2338 PyObject * obj0 = 0 ;
2339 PyObject * obj1 = 0 ;
2340 PyObject * obj2 = 0 ;
2341 char *kwnames[] = {
2342 (char *) "red",(char *) "green",(char *) "blue", NULL
2343 };
2344
2345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2346 if (obj0) {
2347 {
2348 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2349 if (SWIG_arg_fail(1)) SWIG_fail;
2350 }
2351 }
2352 if (obj1) {
2353 {
2354 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2355 if (SWIG_arg_fail(2)) SWIG_fail;
2356 }
2357 }
2358 if (obj2) {
2359 {
2360 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2361 if (SWIG_arg_fail(3)) SWIG_fail;
2362 }
2363 }
2364 {
2365 PyThreadState* __tstate = wxPyBeginAllowThreads();
2366 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2367
2368 wxPyEndAllowThreads(__tstate);
2369 if (PyErr_Occurred()) SWIG_fail;
2370 }
2371 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2372 return resultobj;
2373 fail:
2374 return NULL;
2375 }
2376
2377
2378 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2379 PyObject *resultobj;
2380 wxString *arg1 = 0 ;
2381 wxColour *result;
2382 bool temp1 = false ;
2383 PyObject * obj0 = 0 ;
2384 char *kwnames[] = {
2385 (char *) "colorName", NULL
2386 };
2387
2388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2389 {
2390 arg1 = wxString_in_helper(obj0);
2391 if (arg1 == NULL) SWIG_fail;
2392 temp1 = true;
2393 }
2394 {
2395 if (!wxPyCheckForApp()) SWIG_fail;
2396 PyThreadState* __tstate = wxPyBeginAllowThreads();
2397 result = (wxColour *)new wxColour((wxString const &)*arg1);
2398
2399 wxPyEndAllowThreads(__tstate);
2400 if (PyErr_Occurred()) SWIG_fail;
2401 }
2402 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2403 {
2404 if (temp1)
2405 delete arg1;
2406 }
2407 return resultobj;
2408 fail:
2409 {
2410 if (temp1)
2411 delete arg1;
2412 }
2413 return NULL;
2414 }
2415
2416
2417 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2418 PyObject *resultobj;
2419 unsigned long arg1 ;
2420 wxColour *result;
2421 PyObject * obj0 = 0 ;
2422 char *kwnames[] = {
2423 (char *) "colRGB", NULL
2424 };
2425
2426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2427 {
2428 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2429 if (SWIG_arg_fail(1)) SWIG_fail;
2430 }
2431 {
2432 PyThreadState* __tstate = wxPyBeginAllowThreads();
2433 result = (wxColour *)new wxColour(arg1);
2434
2435 wxPyEndAllowThreads(__tstate);
2436 if (PyErr_Occurred()) SWIG_fail;
2437 }
2438 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2439 return resultobj;
2440 fail:
2441 return NULL;
2442 }
2443
2444
2445 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2446 PyObject *resultobj;
2447 wxColour *arg1 = (wxColour *) 0 ;
2448 PyObject * obj0 = 0 ;
2449 char *kwnames[] = {
2450 (char *) "self", NULL
2451 };
2452
2453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2455 if (SWIG_arg_fail(1)) SWIG_fail;
2456 {
2457 PyThreadState* __tstate = wxPyBeginAllowThreads();
2458 delete arg1;
2459
2460 wxPyEndAllowThreads(__tstate);
2461 if (PyErr_Occurred()) SWIG_fail;
2462 }
2463 Py_INCREF(Py_None); resultobj = Py_None;
2464 return resultobj;
2465 fail:
2466 return NULL;
2467 }
2468
2469
2470 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2471 PyObject *resultobj;
2472 wxColour *arg1 = (wxColour *) 0 ;
2473 byte result;
2474 PyObject * obj0 = 0 ;
2475 char *kwnames[] = {
2476 (char *) "self", NULL
2477 };
2478
2479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2481 if (SWIG_arg_fail(1)) SWIG_fail;
2482 {
2483 PyThreadState* __tstate = wxPyBeginAllowThreads();
2484 result = (byte)(arg1)->Red();
2485
2486 wxPyEndAllowThreads(__tstate);
2487 if (PyErr_Occurred()) SWIG_fail;
2488 }
2489 {
2490 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2491 }
2492 return resultobj;
2493 fail:
2494 return NULL;
2495 }
2496
2497
2498 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2499 PyObject *resultobj;
2500 wxColour *arg1 = (wxColour *) 0 ;
2501 byte result;
2502 PyObject * obj0 = 0 ;
2503 char *kwnames[] = {
2504 (char *) "self", NULL
2505 };
2506
2507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2509 if (SWIG_arg_fail(1)) SWIG_fail;
2510 {
2511 PyThreadState* __tstate = wxPyBeginAllowThreads();
2512 result = (byte)(arg1)->Green();
2513
2514 wxPyEndAllowThreads(__tstate);
2515 if (PyErr_Occurred()) SWIG_fail;
2516 }
2517 {
2518 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2519 }
2520 return resultobj;
2521 fail:
2522 return NULL;
2523 }
2524
2525
2526 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2527 PyObject *resultobj;
2528 wxColour *arg1 = (wxColour *) 0 ;
2529 byte result;
2530 PyObject * obj0 = 0 ;
2531 char *kwnames[] = {
2532 (char *) "self", NULL
2533 };
2534
2535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2537 if (SWIG_arg_fail(1)) SWIG_fail;
2538 {
2539 PyThreadState* __tstate = wxPyBeginAllowThreads();
2540 result = (byte)(arg1)->Blue();
2541
2542 wxPyEndAllowThreads(__tstate);
2543 if (PyErr_Occurred()) SWIG_fail;
2544 }
2545 {
2546 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2547 }
2548 return resultobj;
2549 fail:
2550 return NULL;
2551 }
2552
2553
2554 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2555 PyObject *resultobj;
2556 wxColour *arg1 = (wxColour *) 0 ;
2557 bool result;
2558 PyObject * obj0 = 0 ;
2559 char *kwnames[] = {
2560 (char *) "self", NULL
2561 };
2562
2563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2565 if (SWIG_arg_fail(1)) SWIG_fail;
2566 {
2567 PyThreadState* __tstate = wxPyBeginAllowThreads();
2568 result = (bool)(arg1)->Ok();
2569
2570 wxPyEndAllowThreads(__tstate);
2571 if (PyErr_Occurred()) SWIG_fail;
2572 }
2573 {
2574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2575 }
2576 return resultobj;
2577 fail:
2578 return NULL;
2579 }
2580
2581
2582 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2583 PyObject *resultobj;
2584 wxColour *arg1 = (wxColour *) 0 ;
2585 byte arg2 ;
2586 byte arg3 ;
2587 byte arg4 ;
2588 PyObject * obj0 = 0 ;
2589 PyObject * obj1 = 0 ;
2590 PyObject * obj2 = 0 ;
2591 PyObject * obj3 = 0 ;
2592 char *kwnames[] = {
2593 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2594 };
2595
2596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2598 if (SWIG_arg_fail(1)) SWIG_fail;
2599 {
2600 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2601 if (SWIG_arg_fail(2)) SWIG_fail;
2602 }
2603 {
2604 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2605 if (SWIG_arg_fail(3)) SWIG_fail;
2606 }
2607 {
2608 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2609 if (SWIG_arg_fail(4)) SWIG_fail;
2610 }
2611 {
2612 PyThreadState* __tstate = wxPyBeginAllowThreads();
2613 (arg1)->Set(arg2,arg3,arg4);
2614
2615 wxPyEndAllowThreads(__tstate);
2616 if (PyErr_Occurred()) SWIG_fail;
2617 }
2618 Py_INCREF(Py_None); resultobj = Py_None;
2619 return resultobj;
2620 fail:
2621 return NULL;
2622 }
2623
2624
2625 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2626 PyObject *resultobj;
2627 wxColour *arg1 = (wxColour *) 0 ;
2628 unsigned long arg2 ;
2629 PyObject * obj0 = 0 ;
2630 PyObject * obj1 = 0 ;
2631 char *kwnames[] = {
2632 (char *) "self",(char *) "colRGB", NULL
2633 };
2634
2635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2637 if (SWIG_arg_fail(1)) SWIG_fail;
2638 {
2639 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2640 if (SWIG_arg_fail(2)) SWIG_fail;
2641 }
2642 {
2643 PyThreadState* __tstate = wxPyBeginAllowThreads();
2644 (arg1)->Set(arg2);
2645
2646 wxPyEndAllowThreads(__tstate);
2647 if (PyErr_Occurred()) SWIG_fail;
2648 }
2649 Py_INCREF(Py_None); resultobj = Py_None;
2650 return resultobj;
2651 fail:
2652 return NULL;
2653 }
2654
2655
2656 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2657 PyObject *resultobj;
2658 wxColour *arg1 = (wxColour *) 0 ;
2659 wxString *arg2 = 0 ;
2660 bool temp2 = false ;
2661 PyObject * obj0 = 0 ;
2662 PyObject * obj1 = 0 ;
2663 char *kwnames[] = {
2664 (char *) "self",(char *) "colourName", NULL
2665 };
2666
2667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2669 if (SWIG_arg_fail(1)) SWIG_fail;
2670 {
2671 arg2 = wxString_in_helper(obj1);
2672 if (arg2 == NULL) SWIG_fail;
2673 temp2 = true;
2674 }
2675 {
2676 PyThreadState* __tstate = wxPyBeginAllowThreads();
2677 (arg1)->InitFromName((wxString const &)*arg2);
2678
2679 wxPyEndAllowThreads(__tstate);
2680 if (PyErr_Occurred()) SWIG_fail;
2681 }
2682 Py_INCREF(Py_None); resultobj = Py_None;
2683 {
2684 if (temp2)
2685 delete arg2;
2686 }
2687 return resultobj;
2688 fail:
2689 {
2690 if (temp2)
2691 delete arg2;
2692 }
2693 return NULL;
2694 }
2695
2696
2697 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2698 PyObject *resultobj;
2699 wxColour *arg1 = (wxColour *) 0 ;
2700 long result;
2701 PyObject * obj0 = 0 ;
2702 char *kwnames[] = {
2703 (char *) "self", NULL
2704 };
2705
2706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2708 if (SWIG_arg_fail(1)) SWIG_fail;
2709 {
2710 PyThreadState* __tstate = wxPyBeginAllowThreads();
2711 result = (long)((wxColour const *)arg1)->GetPixel();
2712
2713 wxPyEndAllowThreads(__tstate);
2714 if (PyErr_Occurred()) SWIG_fail;
2715 }
2716 {
2717 resultobj = SWIG_From_long((long)(result));
2718 }
2719 return resultobj;
2720 fail:
2721 return NULL;
2722 }
2723
2724
2725 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2726 PyObject *resultobj;
2727 wxColour *arg1 = (wxColour *) 0 ;
2728 wxColour *arg2 = 0 ;
2729 bool result;
2730 wxColour temp2 ;
2731 PyObject * obj0 = 0 ;
2732 PyObject * obj1 = 0 ;
2733 char *kwnames[] = {
2734 (char *) "self",(char *) "colour", NULL
2735 };
2736
2737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2739 if (SWIG_arg_fail(1)) SWIG_fail;
2740 {
2741 arg2 = &temp2;
2742 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2743 }
2744 {
2745 PyThreadState* __tstate = wxPyBeginAllowThreads();
2746 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2747
2748 wxPyEndAllowThreads(__tstate);
2749 if (PyErr_Occurred()) SWIG_fail;
2750 }
2751 {
2752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2753 }
2754 return resultobj;
2755 fail:
2756 return NULL;
2757 }
2758
2759
2760 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2761 PyObject *resultobj;
2762 wxColour *arg1 = (wxColour *) 0 ;
2763 wxColour *arg2 = 0 ;
2764 bool result;
2765 wxColour temp2 ;
2766 PyObject * obj0 = 0 ;
2767 PyObject * obj1 = 0 ;
2768 char *kwnames[] = {
2769 (char *) "self",(char *) "colour", NULL
2770 };
2771
2772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2774 if (SWIG_arg_fail(1)) SWIG_fail;
2775 {
2776 arg2 = &temp2;
2777 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2778 }
2779 {
2780 PyThreadState* __tstate = wxPyBeginAllowThreads();
2781 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2782
2783 wxPyEndAllowThreads(__tstate);
2784 if (PyErr_Occurred()) SWIG_fail;
2785 }
2786 {
2787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2788 }
2789 return resultobj;
2790 fail:
2791 return NULL;
2792 }
2793
2794
2795 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2796 PyObject *resultobj;
2797 wxColour *arg1 = (wxColour *) 0 ;
2798 PyObject *result;
2799 PyObject * obj0 = 0 ;
2800 char *kwnames[] = {
2801 (char *) "self", NULL
2802 };
2803
2804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2806 if (SWIG_arg_fail(1)) SWIG_fail;
2807 {
2808 PyThreadState* __tstate = wxPyBeginAllowThreads();
2809 result = (PyObject *)wxColour_Get(arg1);
2810
2811 wxPyEndAllowThreads(__tstate);
2812 if (PyErr_Occurred()) SWIG_fail;
2813 }
2814 resultobj = result;
2815 return resultobj;
2816 fail:
2817 return NULL;
2818 }
2819
2820
2821 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2822 PyObject *resultobj;
2823 wxColour *arg1 = (wxColour *) 0 ;
2824 unsigned long result;
2825 PyObject * obj0 = 0 ;
2826 char *kwnames[] = {
2827 (char *) "self", NULL
2828 };
2829
2830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2832 if (SWIG_arg_fail(1)) SWIG_fail;
2833 {
2834 PyThreadState* __tstate = wxPyBeginAllowThreads();
2835 result = (unsigned long)wxColour_GetRGB(arg1);
2836
2837 wxPyEndAllowThreads(__tstate);
2838 if (PyErr_Occurred()) SWIG_fail;
2839 }
2840 {
2841 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2842 }
2843 return resultobj;
2844 fail:
2845 return NULL;
2846 }
2847
2848
2849 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2850 PyObject *obj;
2851 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2852 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2853 Py_INCREF(obj);
2854 return Py_BuildValue((char *)"");
2855 }
2856 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2857 PyObject *resultobj;
2858 int arg1 ;
2859 unsigned char *arg2 = (unsigned char *) 0 ;
2860 unsigned char *arg3 = (unsigned char *) 0 ;
2861 unsigned char *arg4 = (unsigned char *) 0 ;
2862 wxPalette *result;
2863 PyObject * obj0 = 0 ;
2864 PyObject * obj1 = 0 ;
2865 PyObject * obj2 = 0 ;
2866 PyObject * obj3 = 0 ;
2867 char *kwnames[] = {
2868 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2869 };
2870
2871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2872 {
2873 arg1 = (int)(SWIG_As_int(obj0));
2874 if (SWIG_arg_fail(1)) SWIG_fail;
2875 }
2876 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2877 if (SWIG_arg_fail(2)) SWIG_fail;
2878 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2879 if (SWIG_arg_fail(3)) SWIG_fail;
2880 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2881 if (SWIG_arg_fail(4)) SWIG_fail;
2882 {
2883 if (!wxPyCheckForApp()) SWIG_fail;
2884 PyThreadState* __tstate = wxPyBeginAllowThreads();
2885 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2886
2887 wxPyEndAllowThreads(__tstate);
2888 if (PyErr_Occurred()) SWIG_fail;
2889 }
2890 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2891 return resultobj;
2892 fail:
2893 return NULL;
2894 }
2895
2896
2897 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2898 PyObject *resultobj;
2899 wxPalette *arg1 = (wxPalette *) 0 ;
2900 PyObject * obj0 = 0 ;
2901 char *kwnames[] = {
2902 (char *) "self", NULL
2903 };
2904
2905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2907 if (SWIG_arg_fail(1)) SWIG_fail;
2908 {
2909 PyThreadState* __tstate = wxPyBeginAllowThreads();
2910 delete arg1;
2911
2912 wxPyEndAllowThreads(__tstate);
2913 if (PyErr_Occurred()) SWIG_fail;
2914 }
2915 Py_INCREF(Py_None); resultobj = Py_None;
2916 return resultobj;
2917 fail:
2918 return NULL;
2919 }
2920
2921
2922 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2923 PyObject *resultobj;
2924 wxPalette *arg1 = (wxPalette *) 0 ;
2925 byte arg2 ;
2926 byte arg3 ;
2927 byte arg4 ;
2928 int result;
2929 PyObject * obj0 = 0 ;
2930 PyObject * obj1 = 0 ;
2931 PyObject * obj2 = 0 ;
2932 PyObject * obj3 = 0 ;
2933 char *kwnames[] = {
2934 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2935 };
2936
2937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2939 if (SWIG_arg_fail(1)) SWIG_fail;
2940 {
2941 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2942 if (SWIG_arg_fail(2)) SWIG_fail;
2943 }
2944 {
2945 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2946 if (SWIG_arg_fail(3)) SWIG_fail;
2947 }
2948 {
2949 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2950 if (SWIG_arg_fail(4)) SWIG_fail;
2951 }
2952 {
2953 PyThreadState* __tstate = wxPyBeginAllowThreads();
2954 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2955
2956 wxPyEndAllowThreads(__tstate);
2957 if (PyErr_Occurred()) SWIG_fail;
2958 }
2959 {
2960 resultobj = SWIG_From_int((int)(result));
2961 }
2962 return resultobj;
2963 fail:
2964 return NULL;
2965 }
2966
2967
2968 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2969 PyObject *resultobj;
2970 wxPalette *arg1 = (wxPalette *) 0 ;
2971 int arg2 ;
2972 byte *arg3 = (byte *) 0 ;
2973 byte *arg4 = (byte *) 0 ;
2974 byte *arg5 = (byte *) 0 ;
2975 bool result;
2976 byte temp3 ;
2977 int res3 = 0 ;
2978 byte temp4 ;
2979 int res4 = 0 ;
2980 byte temp5 ;
2981 int res5 = 0 ;
2982 PyObject * obj0 = 0 ;
2983 PyObject * obj1 = 0 ;
2984 char *kwnames[] = {
2985 (char *) "self",(char *) "pixel", NULL
2986 };
2987
2988 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2989 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2990 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2993 if (SWIG_arg_fail(1)) SWIG_fail;
2994 {
2995 arg2 = (int)(SWIG_As_int(obj1));
2996 if (SWIG_arg_fail(2)) SWIG_fail;
2997 }
2998 {
2999 PyThreadState* __tstate = wxPyBeginAllowThreads();
3000 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
3001
3002 wxPyEndAllowThreads(__tstate);
3003 if (PyErr_Occurred()) SWIG_fail;
3004 }
3005 {
3006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3007 }
3008 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
3009 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
3010 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
3011 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
3012 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
3013 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
3014 return resultobj;
3015 fail:
3016 return NULL;
3017 }
3018
3019
3020 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
3021 PyObject *resultobj;
3022 wxPalette *arg1 = (wxPalette *) 0 ;
3023 int result;
3024 PyObject * obj0 = 0 ;
3025 char *kwnames[] = {
3026 (char *) "self", NULL
3027 };
3028
3029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
3030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3031 if (SWIG_arg_fail(1)) SWIG_fail;
3032 {
3033 PyThreadState* __tstate = wxPyBeginAllowThreads();
3034 result = (int)((wxPalette const *)arg1)->GetColoursCount();
3035
3036 wxPyEndAllowThreads(__tstate);
3037 if (PyErr_Occurred()) SWIG_fail;
3038 }
3039 {
3040 resultobj = SWIG_From_int((int)(result));
3041 }
3042 return resultobj;
3043 fail:
3044 return NULL;
3045 }
3046
3047
3048 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3049 PyObject *resultobj;
3050 wxPalette *arg1 = (wxPalette *) 0 ;
3051 bool result;
3052 PyObject * obj0 = 0 ;
3053 char *kwnames[] = {
3054 (char *) "self", NULL
3055 };
3056
3057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
3058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3059 if (SWIG_arg_fail(1)) SWIG_fail;
3060 {
3061 PyThreadState* __tstate = wxPyBeginAllowThreads();
3062 result = (bool)(arg1)->Ok();
3063
3064 wxPyEndAllowThreads(__tstate);
3065 if (PyErr_Occurred()) SWIG_fail;
3066 }
3067 {
3068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3069 }
3070 return resultobj;
3071 fail:
3072 return NULL;
3073 }
3074
3075
3076 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3077 PyObject *obj;
3078 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3079 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3080 Py_INCREF(obj);
3081 return Py_BuildValue((char *)"");
3082 }
3083 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3084 PyObject *resultobj;
3085 wxColour *arg1 = 0 ;
3086 int arg2 = (int) 1 ;
3087 int arg3 = (int) wxSOLID ;
3088 wxPen *result;
3089 wxColour temp1 ;
3090 PyObject * obj0 = 0 ;
3091 PyObject * obj1 = 0 ;
3092 PyObject * obj2 = 0 ;
3093 char *kwnames[] = {
3094 (char *) "colour",(char *) "width",(char *) "style", NULL
3095 };
3096
3097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3098 {
3099 arg1 = &temp1;
3100 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3101 }
3102 if (obj1) {
3103 {
3104 arg2 = (int)(SWIG_As_int(obj1));
3105 if (SWIG_arg_fail(2)) SWIG_fail;
3106 }
3107 }
3108 if (obj2) {
3109 {
3110 arg3 = (int)(SWIG_As_int(obj2));
3111 if (SWIG_arg_fail(3)) SWIG_fail;
3112 }
3113 }
3114 {
3115 if (!wxPyCheckForApp()) SWIG_fail;
3116 PyThreadState* __tstate = wxPyBeginAllowThreads();
3117 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3118
3119 wxPyEndAllowThreads(__tstate);
3120 if (PyErr_Occurred()) SWIG_fail;
3121 }
3122 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3123 return resultobj;
3124 fail:
3125 return NULL;
3126 }
3127
3128
3129 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3130 PyObject *resultobj;
3131 wxPen *arg1 = (wxPen *) 0 ;
3132 PyObject * obj0 = 0 ;
3133 char *kwnames[] = {
3134 (char *) "self", NULL
3135 };
3136
3137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3139 if (SWIG_arg_fail(1)) SWIG_fail;
3140 {
3141 PyThreadState* __tstate = wxPyBeginAllowThreads();
3142 delete arg1;
3143
3144 wxPyEndAllowThreads(__tstate);
3145 if (PyErr_Occurred()) SWIG_fail;
3146 }
3147 Py_INCREF(Py_None); resultobj = Py_None;
3148 return resultobj;
3149 fail:
3150 return NULL;
3151 }
3152
3153
3154 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3155 PyObject *resultobj;
3156 wxPen *arg1 = (wxPen *) 0 ;
3157 int result;
3158 PyObject * obj0 = 0 ;
3159 char *kwnames[] = {
3160 (char *) "self", NULL
3161 };
3162
3163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3165 if (SWIG_arg_fail(1)) SWIG_fail;
3166 {
3167 PyThreadState* __tstate = wxPyBeginAllowThreads();
3168 result = (int)(arg1)->GetCap();
3169
3170 wxPyEndAllowThreads(__tstate);
3171 if (PyErr_Occurred()) SWIG_fail;
3172 }
3173 {
3174 resultobj = SWIG_From_int((int)(result));
3175 }
3176 return resultobj;
3177 fail:
3178 return NULL;
3179 }
3180
3181
3182 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3183 PyObject *resultobj;
3184 wxPen *arg1 = (wxPen *) 0 ;
3185 wxColour result;
3186 PyObject * obj0 = 0 ;
3187 char *kwnames[] = {
3188 (char *) "self", NULL
3189 };
3190
3191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3193 if (SWIG_arg_fail(1)) SWIG_fail;
3194 {
3195 PyThreadState* __tstate = wxPyBeginAllowThreads();
3196 result = (arg1)->GetColour();
3197
3198 wxPyEndAllowThreads(__tstate);
3199 if (PyErr_Occurred()) SWIG_fail;
3200 }
3201 {
3202 wxColour * resultptr;
3203 resultptr = new wxColour((wxColour &)(result));
3204 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3205 }
3206 return resultobj;
3207 fail:
3208 return NULL;
3209 }
3210
3211
3212 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3213 PyObject *resultobj;
3214 wxPen *arg1 = (wxPen *) 0 ;
3215 int result;
3216 PyObject * obj0 = 0 ;
3217 char *kwnames[] = {
3218 (char *) "self", NULL
3219 };
3220
3221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3223 if (SWIG_arg_fail(1)) SWIG_fail;
3224 {
3225 PyThreadState* __tstate = wxPyBeginAllowThreads();
3226 result = (int)(arg1)->GetJoin();
3227
3228 wxPyEndAllowThreads(__tstate);
3229 if (PyErr_Occurred()) SWIG_fail;
3230 }
3231 {
3232 resultobj = SWIG_From_int((int)(result));
3233 }
3234 return resultobj;
3235 fail:
3236 return NULL;
3237 }
3238
3239
3240 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3241 PyObject *resultobj;
3242 wxPen *arg1 = (wxPen *) 0 ;
3243 int result;
3244 PyObject * obj0 = 0 ;
3245 char *kwnames[] = {
3246 (char *) "self", NULL
3247 };
3248
3249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3251 if (SWIG_arg_fail(1)) SWIG_fail;
3252 {
3253 PyThreadState* __tstate = wxPyBeginAllowThreads();
3254 result = (int)(arg1)->GetStyle();
3255
3256 wxPyEndAllowThreads(__tstate);
3257 if (PyErr_Occurred()) SWIG_fail;
3258 }
3259 {
3260 resultobj = SWIG_From_int((int)(result));
3261 }
3262 return resultobj;
3263 fail:
3264 return NULL;
3265 }
3266
3267
3268 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3269 PyObject *resultobj;
3270 wxPen *arg1 = (wxPen *) 0 ;
3271 int result;
3272 PyObject * obj0 = 0 ;
3273 char *kwnames[] = {
3274 (char *) "self", NULL
3275 };
3276
3277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3279 if (SWIG_arg_fail(1)) SWIG_fail;
3280 {
3281 PyThreadState* __tstate = wxPyBeginAllowThreads();
3282 result = (int)(arg1)->GetWidth();
3283
3284 wxPyEndAllowThreads(__tstate);
3285 if (PyErr_Occurred()) SWIG_fail;
3286 }
3287 {
3288 resultobj = SWIG_From_int((int)(result));
3289 }
3290 return resultobj;
3291 fail:
3292 return NULL;
3293 }
3294
3295
3296 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3297 PyObject *resultobj;
3298 wxPen *arg1 = (wxPen *) 0 ;
3299 bool result;
3300 PyObject * obj0 = 0 ;
3301 char *kwnames[] = {
3302 (char *) "self", NULL
3303 };
3304
3305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3307 if (SWIG_arg_fail(1)) SWIG_fail;
3308 {
3309 PyThreadState* __tstate = wxPyBeginAllowThreads();
3310 result = (bool)(arg1)->Ok();
3311
3312 wxPyEndAllowThreads(__tstate);
3313 if (PyErr_Occurred()) SWIG_fail;
3314 }
3315 {
3316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3317 }
3318 return resultobj;
3319 fail:
3320 return NULL;
3321 }
3322
3323
3324 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3325 PyObject *resultobj;
3326 wxPen *arg1 = (wxPen *) 0 ;
3327 int arg2 ;
3328 PyObject * obj0 = 0 ;
3329 PyObject * obj1 = 0 ;
3330 char *kwnames[] = {
3331 (char *) "self",(char *) "cap_style", NULL
3332 };
3333
3334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3336 if (SWIG_arg_fail(1)) SWIG_fail;
3337 {
3338 arg2 = (int)(SWIG_As_int(obj1));
3339 if (SWIG_arg_fail(2)) SWIG_fail;
3340 }
3341 {
3342 PyThreadState* __tstate = wxPyBeginAllowThreads();
3343 (arg1)->SetCap(arg2);
3344
3345 wxPyEndAllowThreads(__tstate);
3346 if (PyErr_Occurred()) SWIG_fail;
3347 }
3348 Py_INCREF(Py_None); resultobj = Py_None;
3349 return resultobj;
3350 fail:
3351 return NULL;
3352 }
3353
3354
3355 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3356 PyObject *resultobj;
3357 wxPen *arg1 = (wxPen *) 0 ;
3358 wxColour *arg2 = 0 ;
3359 wxColour temp2 ;
3360 PyObject * obj0 = 0 ;
3361 PyObject * obj1 = 0 ;
3362 char *kwnames[] = {
3363 (char *) "self",(char *) "colour", NULL
3364 };
3365
3366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3368 if (SWIG_arg_fail(1)) SWIG_fail;
3369 {
3370 arg2 = &temp2;
3371 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3372 }
3373 {
3374 PyThreadState* __tstate = wxPyBeginAllowThreads();
3375 (arg1)->SetColour(*arg2);
3376
3377 wxPyEndAllowThreads(__tstate);
3378 if (PyErr_Occurred()) SWIG_fail;
3379 }
3380 Py_INCREF(Py_None); resultobj = Py_None;
3381 return resultobj;
3382 fail:
3383 return NULL;
3384 }
3385
3386
3387 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3388 PyObject *resultobj;
3389 wxPen *arg1 = (wxPen *) 0 ;
3390 int arg2 ;
3391 PyObject * obj0 = 0 ;
3392 PyObject * obj1 = 0 ;
3393 char *kwnames[] = {
3394 (char *) "self",(char *) "join_style", NULL
3395 };
3396
3397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3399 if (SWIG_arg_fail(1)) SWIG_fail;
3400 {
3401 arg2 = (int)(SWIG_As_int(obj1));
3402 if (SWIG_arg_fail(2)) SWIG_fail;
3403 }
3404 {
3405 PyThreadState* __tstate = wxPyBeginAllowThreads();
3406 (arg1)->SetJoin(arg2);
3407
3408 wxPyEndAllowThreads(__tstate);
3409 if (PyErr_Occurred()) SWIG_fail;
3410 }
3411 Py_INCREF(Py_None); resultobj = Py_None;
3412 return resultobj;
3413 fail:
3414 return NULL;
3415 }
3416
3417
3418 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3419 PyObject *resultobj;
3420 wxPen *arg1 = (wxPen *) 0 ;
3421 int arg2 ;
3422 PyObject * obj0 = 0 ;
3423 PyObject * obj1 = 0 ;
3424 char *kwnames[] = {
3425 (char *) "self",(char *) "style", NULL
3426 };
3427
3428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3430 if (SWIG_arg_fail(1)) SWIG_fail;
3431 {
3432 arg2 = (int)(SWIG_As_int(obj1));
3433 if (SWIG_arg_fail(2)) SWIG_fail;
3434 }
3435 {
3436 PyThreadState* __tstate = wxPyBeginAllowThreads();
3437 (arg1)->SetStyle(arg2);
3438
3439 wxPyEndAllowThreads(__tstate);
3440 if (PyErr_Occurred()) SWIG_fail;
3441 }
3442 Py_INCREF(Py_None); resultobj = Py_None;
3443 return resultobj;
3444 fail:
3445 return NULL;
3446 }
3447
3448
3449 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3450 PyObject *resultobj;
3451 wxPen *arg1 = (wxPen *) 0 ;
3452 int arg2 ;
3453 PyObject * obj0 = 0 ;
3454 PyObject * obj1 = 0 ;
3455 char *kwnames[] = {
3456 (char *) "self",(char *) "width", NULL
3457 };
3458
3459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3461 if (SWIG_arg_fail(1)) SWIG_fail;
3462 {
3463 arg2 = (int)(SWIG_As_int(obj1));
3464 if (SWIG_arg_fail(2)) SWIG_fail;
3465 }
3466 {
3467 PyThreadState* __tstate = wxPyBeginAllowThreads();
3468 (arg1)->SetWidth(arg2);
3469
3470 wxPyEndAllowThreads(__tstate);
3471 if (PyErr_Occurred()) SWIG_fail;
3472 }
3473 Py_INCREF(Py_None); resultobj = Py_None;
3474 return resultobj;
3475 fail:
3476 return NULL;
3477 }
3478
3479
3480 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3481 PyObject *resultobj;
3482 wxPen *arg1 = (wxPen *) 0 ;
3483 int arg2 ;
3484 wxDash *arg3 = (wxDash *) 0 ;
3485 PyObject * obj0 = 0 ;
3486 PyObject * obj1 = 0 ;
3487 char *kwnames[] = {
3488 (char *) "self",(char *) "dashes", NULL
3489 };
3490
3491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3493 if (SWIG_arg_fail(1)) SWIG_fail;
3494 {
3495 arg2 = PyList_Size(obj1);
3496 arg3 = (wxDash*)byte_LIST_helper(obj1);
3497 if (arg3 == NULL) SWIG_fail;
3498 }
3499 {
3500 PyThreadState* __tstate = wxPyBeginAllowThreads();
3501 (arg1)->SetDashes(arg2,arg3);
3502
3503 wxPyEndAllowThreads(__tstate);
3504 if (PyErr_Occurred()) SWIG_fail;
3505 }
3506 Py_INCREF(Py_None); resultobj = Py_None;
3507 {
3508 if (arg3) delete [] arg3;
3509 }
3510 return resultobj;
3511 fail:
3512 {
3513 if (arg3) delete [] arg3;
3514 }
3515 return NULL;
3516 }
3517
3518
3519 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3520 PyObject *resultobj;
3521 wxPen *arg1 = (wxPen *) 0 ;
3522 PyObject *result;
3523 PyObject * obj0 = 0 ;
3524 char *kwnames[] = {
3525 (char *) "self", NULL
3526 };
3527
3528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3530 if (SWIG_arg_fail(1)) SWIG_fail;
3531 {
3532 PyThreadState* __tstate = wxPyBeginAllowThreads();
3533 result = (PyObject *)wxPen_GetDashes(arg1);
3534
3535 wxPyEndAllowThreads(__tstate);
3536 if (PyErr_Occurred()) SWIG_fail;
3537 }
3538 resultobj = result;
3539 return resultobj;
3540 fail:
3541 return NULL;
3542 }
3543
3544
3545 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3546 PyObject *resultobj;
3547 wxPen *arg1 = (wxPen *) 0 ;
3548 PyObject *arg2 = (PyObject *) 0 ;
3549 PyObject *arg3 = (PyObject *) 0 ;
3550 PyObject * obj0 = 0 ;
3551 PyObject * obj1 = 0 ;
3552 PyObject * obj2 = 0 ;
3553 char *kwnames[] = {
3554 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3555 };
3556
3557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3559 if (SWIG_arg_fail(1)) SWIG_fail;
3560 arg2 = obj1;
3561 arg3 = obj2;
3562 {
3563 PyThreadState* __tstate = wxPyBeginAllowThreads();
3564 wxPen__SetDashes(arg1,arg2,arg3);
3565
3566 wxPyEndAllowThreads(__tstate);
3567 if (PyErr_Occurred()) SWIG_fail;
3568 }
3569 Py_INCREF(Py_None); resultobj = Py_None;
3570 return resultobj;
3571 fail:
3572 return NULL;
3573 }
3574
3575
3576 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3577 PyObject *resultobj;
3578 wxPen *arg1 = (wxPen *) 0 ;
3579 wxPen *arg2 = (wxPen *) 0 ;
3580 bool result;
3581 PyObject * obj0 = 0 ;
3582 PyObject * obj1 = 0 ;
3583 char *kwnames[] = {
3584 (char *) "self",(char *) "other", NULL
3585 };
3586
3587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3589 if (SWIG_arg_fail(1)) SWIG_fail;
3590 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3591 if (SWIG_arg_fail(2)) SWIG_fail;
3592 {
3593 PyThreadState* __tstate = wxPyBeginAllowThreads();
3594 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3595
3596 wxPyEndAllowThreads(__tstate);
3597 if (PyErr_Occurred()) SWIG_fail;
3598 }
3599 {
3600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3601 }
3602 return resultobj;
3603 fail:
3604 return NULL;
3605 }
3606
3607
3608 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3609 PyObject *resultobj;
3610 wxPen *arg1 = (wxPen *) 0 ;
3611 wxPen *arg2 = (wxPen *) 0 ;
3612 bool result;
3613 PyObject * obj0 = 0 ;
3614 PyObject * obj1 = 0 ;
3615 char *kwnames[] = {
3616 (char *) "self",(char *) "other", NULL
3617 };
3618
3619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3621 if (SWIG_arg_fail(1)) SWIG_fail;
3622 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3623 if (SWIG_arg_fail(2)) SWIG_fail;
3624 {
3625 PyThreadState* __tstate = wxPyBeginAllowThreads();
3626 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3627
3628 wxPyEndAllowThreads(__tstate);
3629 if (PyErr_Occurred()) SWIG_fail;
3630 }
3631 {
3632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3633 }
3634 return resultobj;
3635 fail:
3636 return NULL;
3637 }
3638
3639
3640 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3641 PyObject *obj;
3642 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3643 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3644 Py_INCREF(obj);
3645 return Py_BuildValue((char *)"");
3646 }
3647 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3648 PyObject *resultobj;
3649 wxColour *arg1 = 0 ;
3650 int arg2 = (int) wxSOLID ;
3651 wxBrush *result;
3652 wxColour temp1 ;
3653 PyObject * obj0 = 0 ;
3654 PyObject * obj1 = 0 ;
3655 char *kwnames[] = {
3656 (char *) "colour",(char *) "style", NULL
3657 };
3658
3659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3660 {
3661 arg1 = &temp1;
3662 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3663 }
3664 if (obj1) {
3665 {
3666 arg2 = (int)(SWIG_As_int(obj1));
3667 if (SWIG_arg_fail(2)) SWIG_fail;
3668 }
3669 }
3670 {
3671 if (!wxPyCheckForApp()) SWIG_fail;
3672 PyThreadState* __tstate = wxPyBeginAllowThreads();
3673 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3674
3675 wxPyEndAllowThreads(__tstate);
3676 if (PyErr_Occurred()) SWIG_fail;
3677 }
3678 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3679 return resultobj;
3680 fail:
3681 return NULL;
3682 }
3683
3684
3685 static PyObject *_wrap_new_BrushFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3686 PyObject *resultobj;
3687 wxBitmap *arg1 = 0 ;
3688 wxBrush *result;
3689 PyObject * obj0 = 0 ;
3690 char *kwnames[] = {
3691 (char *) "stippleBitmap", NULL
3692 };
3693
3694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BrushFromBitmap",kwnames,&obj0)) goto fail;
3695 {
3696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3697 if (SWIG_arg_fail(1)) SWIG_fail;
3698 if (arg1 == NULL) {
3699 SWIG_null_ref("wxBitmap");
3700 }
3701 if (SWIG_arg_fail(1)) SWIG_fail;
3702 }
3703 {
3704 if (!wxPyCheckForApp()) SWIG_fail;
3705 PyThreadState* __tstate = wxPyBeginAllowThreads();
3706 result = (wxBrush *)new wxBrush((wxBitmap const &)*arg1);
3707
3708 wxPyEndAllowThreads(__tstate);
3709 if (PyErr_Occurred()) SWIG_fail;
3710 }
3711 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3712 return resultobj;
3713 fail:
3714 return NULL;
3715 }
3716
3717
3718 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3719 PyObject *resultobj;
3720 wxBrush *arg1 = (wxBrush *) 0 ;
3721 PyObject * obj0 = 0 ;
3722 char *kwnames[] = {
3723 (char *) "self", NULL
3724 };
3725
3726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3728 if (SWIG_arg_fail(1)) SWIG_fail;
3729 {
3730 PyThreadState* __tstate = wxPyBeginAllowThreads();
3731 delete arg1;
3732
3733 wxPyEndAllowThreads(__tstate);
3734 if (PyErr_Occurred()) SWIG_fail;
3735 }
3736 Py_INCREF(Py_None); resultobj = Py_None;
3737 return resultobj;
3738 fail:
3739 return NULL;
3740 }
3741
3742
3743 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3744 PyObject *resultobj;
3745 wxBrush *arg1 = (wxBrush *) 0 ;
3746 wxColour *arg2 = 0 ;
3747 wxColour temp2 ;
3748 PyObject * obj0 = 0 ;
3749 PyObject * obj1 = 0 ;
3750 char *kwnames[] = {
3751 (char *) "self",(char *) "col", NULL
3752 };
3753
3754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3756 if (SWIG_arg_fail(1)) SWIG_fail;
3757 {
3758 arg2 = &temp2;
3759 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3760 }
3761 {
3762 PyThreadState* __tstate = wxPyBeginAllowThreads();
3763 (arg1)->SetColour((wxColour const &)*arg2);
3764
3765 wxPyEndAllowThreads(__tstate);
3766 if (PyErr_Occurred()) SWIG_fail;
3767 }
3768 Py_INCREF(Py_None); resultobj = Py_None;
3769 return resultobj;
3770 fail:
3771 return NULL;
3772 }
3773
3774
3775 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3776 PyObject *resultobj;
3777 wxBrush *arg1 = (wxBrush *) 0 ;
3778 int arg2 ;
3779 PyObject * obj0 = 0 ;
3780 PyObject * obj1 = 0 ;
3781 char *kwnames[] = {
3782 (char *) "self",(char *) "style", NULL
3783 };
3784
3785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3787 if (SWIG_arg_fail(1)) SWIG_fail;
3788 {
3789 arg2 = (int)(SWIG_As_int(obj1));
3790 if (SWIG_arg_fail(2)) SWIG_fail;
3791 }
3792 {
3793 PyThreadState* __tstate = wxPyBeginAllowThreads();
3794 (arg1)->SetStyle(arg2);
3795
3796 wxPyEndAllowThreads(__tstate);
3797 if (PyErr_Occurred()) SWIG_fail;
3798 }
3799 Py_INCREF(Py_None); resultobj = Py_None;
3800 return resultobj;
3801 fail:
3802 return NULL;
3803 }
3804
3805
3806 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3807 PyObject *resultobj;
3808 wxBrush *arg1 = (wxBrush *) 0 ;
3809 wxBitmap *arg2 = 0 ;
3810 PyObject * obj0 = 0 ;
3811 PyObject * obj1 = 0 ;
3812 char *kwnames[] = {
3813 (char *) "self",(char *) "stipple", NULL
3814 };
3815
3816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3818 if (SWIG_arg_fail(1)) SWIG_fail;
3819 {
3820 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3821 if (SWIG_arg_fail(2)) SWIG_fail;
3822 if (arg2 == NULL) {
3823 SWIG_null_ref("wxBitmap");
3824 }
3825 if (SWIG_arg_fail(2)) SWIG_fail;
3826 }
3827 {
3828 PyThreadState* __tstate = wxPyBeginAllowThreads();
3829 (arg1)->SetStipple((wxBitmap const &)*arg2);
3830
3831 wxPyEndAllowThreads(__tstate);
3832 if (PyErr_Occurred()) SWIG_fail;
3833 }
3834 Py_INCREF(Py_None); resultobj = Py_None;
3835 return resultobj;
3836 fail:
3837 return NULL;
3838 }
3839
3840
3841 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3842 PyObject *resultobj;
3843 wxBrush *arg1 = (wxBrush *) 0 ;
3844 wxColour result;
3845 PyObject * obj0 = 0 ;
3846 char *kwnames[] = {
3847 (char *) "self", NULL
3848 };
3849
3850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3852 if (SWIG_arg_fail(1)) SWIG_fail;
3853 {
3854 PyThreadState* __tstate = wxPyBeginAllowThreads();
3855 result = ((wxBrush const *)arg1)->GetColour();
3856
3857 wxPyEndAllowThreads(__tstate);
3858 if (PyErr_Occurred()) SWIG_fail;
3859 }
3860 {
3861 wxColour * resultptr;
3862 resultptr = new wxColour((wxColour &)(result));
3863 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3864 }
3865 return resultobj;
3866 fail:
3867 return NULL;
3868 }
3869
3870
3871 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3872 PyObject *resultobj;
3873 wxBrush *arg1 = (wxBrush *) 0 ;
3874 int result;
3875 PyObject * obj0 = 0 ;
3876 char *kwnames[] = {
3877 (char *) "self", NULL
3878 };
3879
3880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3882 if (SWIG_arg_fail(1)) SWIG_fail;
3883 {
3884 PyThreadState* __tstate = wxPyBeginAllowThreads();
3885 result = (int)((wxBrush const *)arg1)->GetStyle();
3886
3887 wxPyEndAllowThreads(__tstate);
3888 if (PyErr_Occurred()) SWIG_fail;
3889 }
3890 {
3891 resultobj = SWIG_From_int((int)(result));
3892 }
3893 return resultobj;
3894 fail:
3895 return NULL;
3896 }
3897
3898
3899 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3900 PyObject *resultobj;
3901 wxBrush *arg1 = (wxBrush *) 0 ;
3902 wxBitmap *result;
3903 PyObject * obj0 = 0 ;
3904 char *kwnames[] = {
3905 (char *) "self", NULL
3906 };
3907
3908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3910 if (SWIG_arg_fail(1)) SWIG_fail;
3911 {
3912 PyThreadState* __tstate = wxPyBeginAllowThreads();
3913 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3914
3915 wxPyEndAllowThreads(__tstate);
3916 if (PyErr_Occurred()) SWIG_fail;
3917 }
3918 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3919 return resultobj;
3920 fail:
3921 return NULL;
3922 }
3923
3924
3925 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3926 PyObject *resultobj;
3927 wxBrush *arg1 = (wxBrush *) 0 ;
3928 bool result;
3929 PyObject * obj0 = 0 ;
3930 char *kwnames[] = {
3931 (char *) "self", NULL
3932 };
3933
3934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3936 if (SWIG_arg_fail(1)) SWIG_fail;
3937 {
3938 PyThreadState* __tstate = wxPyBeginAllowThreads();
3939 result = (bool)((wxBrush const *)arg1)->IsHatch();
3940
3941 wxPyEndAllowThreads(__tstate);
3942 if (PyErr_Occurred()) SWIG_fail;
3943 }
3944 {
3945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3946 }
3947 return resultobj;
3948 fail:
3949 return NULL;
3950 }
3951
3952
3953 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3954 PyObject *resultobj;
3955 wxBrush *arg1 = (wxBrush *) 0 ;
3956 bool result;
3957 PyObject * obj0 = 0 ;
3958 char *kwnames[] = {
3959 (char *) "self", NULL
3960 };
3961
3962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3964 if (SWIG_arg_fail(1)) SWIG_fail;
3965 {
3966 PyThreadState* __tstate = wxPyBeginAllowThreads();
3967 result = (bool)(arg1)->Ok();
3968
3969 wxPyEndAllowThreads(__tstate);
3970 if (PyErr_Occurred()) SWIG_fail;
3971 }
3972 {
3973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3974 }
3975 return resultobj;
3976 fail:
3977 return NULL;
3978 }
3979
3980
3981 static PyObject *_wrap_Brush_MacGetTheme(PyObject *, PyObject *args, PyObject *kwargs) {
3982 PyObject *resultobj;
3983 wxBrush *arg1 = (wxBrush *) 0 ;
3984 short result;
3985 PyObject * obj0 = 0 ;
3986 char *kwnames[] = {
3987 (char *) "self", NULL
3988 };
3989
3990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_MacGetTheme",kwnames,&obj0)) goto fail;
3991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3992 if (SWIG_arg_fail(1)) SWIG_fail;
3993 {
3994 PyThreadState* __tstate = wxPyBeginAllowThreads();
3995 result = (short)(arg1)->MacGetTheme();
3996
3997 wxPyEndAllowThreads(__tstate);
3998 if (PyErr_Occurred()) SWIG_fail;
3999 }
4000 {
4001 resultobj = SWIG_From_short((short)(result));
4002 }
4003 return resultobj;
4004 fail:
4005 return NULL;
4006 }
4007
4008
4009 static PyObject *_wrap_Brush_MacSetTheme(PyObject *, PyObject *args, PyObject *kwargs) {
4010 PyObject *resultobj;
4011 wxBrush *arg1 = (wxBrush *) 0 ;
4012 short arg2 ;
4013 PyObject * obj0 = 0 ;
4014 PyObject * obj1 = 0 ;
4015 char *kwnames[] = {
4016 (char *) "self",(char *) "macThemeBrush", NULL
4017 };
4018
4019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_MacSetTheme",kwnames,&obj0,&obj1)) goto fail;
4020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
4021 if (SWIG_arg_fail(1)) SWIG_fail;
4022 {
4023 arg2 = (short)(SWIG_As_short(obj1));
4024 if (SWIG_arg_fail(2)) SWIG_fail;
4025 }
4026 {
4027 PyThreadState* __tstate = wxPyBeginAllowThreads();
4028 (arg1)->MacSetTheme(arg2);
4029
4030 wxPyEndAllowThreads(__tstate);
4031 if (PyErr_Occurred()) SWIG_fail;
4032 }
4033 Py_INCREF(Py_None); resultobj = Py_None;
4034 return resultobj;
4035 fail:
4036 return NULL;
4037 }
4038
4039
4040 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
4041 PyObject *obj;
4042 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4043 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
4044 Py_INCREF(obj);
4045 return Py_BuildValue((char *)"");
4046 }
4047 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4048 PyObject *resultobj;
4049 wxString *arg1 = 0 ;
4050 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
4051 wxBitmap *result;
4052 bool temp1 = false ;
4053 PyObject * obj0 = 0 ;
4054 PyObject * obj1 = 0 ;
4055 char *kwnames[] = {
4056 (char *) "name",(char *) "type", NULL
4057 };
4058
4059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
4060 {
4061 arg1 = wxString_in_helper(obj0);
4062 if (arg1 == NULL) SWIG_fail;
4063 temp1 = true;
4064 }
4065 if (obj1) {
4066 {
4067 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4068 if (SWIG_arg_fail(2)) SWIG_fail;
4069 }
4070 }
4071 {
4072 if (!wxPyCheckForApp()) SWIG_fail;
4073 PyThreadState* __tstate = wxPyBeginAllowThreads();
4074 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
4075
4076 wxPyEndAllowThreads(__tstate);
4077 if (PyErr_Occurred()) SWIG_fail;
4078 }
4079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4080 {
4081 if (temp1)
4082 delete arg1;
4083 }
4084 return resultobj;
4085 fail:
4086 {
4087 if (temp1)
4088 delete arg1;
4089 }
4090 return NULL;
4091 }
4092
4093
4094 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4095 PyObject *resultobj;
4096 wxBitmap *arg1 = (wxBitmap *) 0 ;
4097 PyObject * obj0 = 0 ;
4098 char *kwnames[] = {
4099 (char *) "self", NULL
4100 };
4101
4102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
4103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4104 if (SWIG_arg_fail(1)) SWIG_fail;
4105 {
4106 PyThreadState* __tstate = wxPyBeginAllowThreads();
4107 delete arg1;
4108
4109 wxPyEndAllowThreads(__tstate);
4110 if (PyErr_Occurred()) SWIG_fail;
4111 }
4112 Py_INCREF(Py_None); resultobj = Py_None;
4113 return resultobj;
4114 fail:
4115 return NULL;
4116 }
4117
4118
4119 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4120 PyObject *resultobj;
4121 int arg1 ;
4122 int arg2 ;
4123 int arg3 = (int) -1 ;
4124 wxBitmap *result;
4125 PyObject * obj0 = 0 ;
4126 PyObject * obj1 = 0 ;
4127 PyObject * obj2 = 0 ;
4128 char *kwnames[] = {
4129 (char *) "width",(char *) "height",(char *) "depth", NULL
4130 };
4131
4132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4133 {
4134 arg1 = (int)(SWIG_As_int(obj0));
4135 if (SWIG_arg_fail(1)) SWIG_fail;
4136 }
4137 {
4138 arg2 = (int)(SWIG_As_int(obj1));
4139 if (SWIG_arg_fail(2)) SWIG_fail;
4140 }
4141 if (obj2) {
4142 {
4143 arg3 = (int)(SWIG_As_int(obj2));
4144 if (SWIG_arg_fail(3)) SWIG_fail;
4145 }
4146 }
4147 {
4148 if (!wxPyCheckForApp()) SWIG_fail;
4149 PyThreadState* __tstate = wxPyBeginAllowThreads();
4150 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4151
4152 wxPyEndAllowThreads(__tstate);
4153 if (PyErr_Occurred()) SWIG_fail;
4154 }
4155 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4156 return resultobj;
4157 fail:
4158 return NULL;
4159 }
4160
4161
4162 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4163 PyObject *resultobj;
4164 wxIcon *arg1 = 0 ;
4165 wxBitmap *result;
4166 PyObject * obj0 = 0 ;
4167 char *kwnames[] = {
4168 (char *) "icon", NULL
4169 };
4170
4171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4172 {
4173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4174 if (SWIG_arg_fail(1)) SWIG_fail;
4175 if (arg1 == NULL) {
4176 SWIG_null_ref("wxIcon");
4177 }
4178 if (SWIG_arg_fail(1)) SWIG_fail;
4179 }
4180 {
4181 if (!wxPyCheckForApp()) SWIG_fail;
4182 PyThreadState* __tstate = wxPyBeginAllowThreads();
4183 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4184
4185 wxPyEndAllowThreads(__tstate);
4186 if (PyErr_Occurred()) SWIG_fail;
4187 }
4188 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4189 return resultobj;
4190 fail:
4191 return NULL;
4192 }
4193
4194
4195 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4196 PyObject *resultobj;
4197 wxImage *arg1 = 0 ;
4198 int arg2 = (int) -1 ;
4199 wxBitmap *result;
4200 PyObject * obj0 = 0 ;
4201 PyObject * obj1 = 0 ;
4202 char *kwnames[] = {
4203 (char *) "image",(char *) "depth", NULL
4204 };
4205
4206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4207 {
4208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4209 if (SWIG_arg_fail(1)) SWIG_fail;
4210 if (arg1 == NULL) {
4211 SWIG_null_ref("wxImage");
4212 }
4213 if (SWIG_arg_fail(1)) SWIG_fail;
4214 }
4215 if (obj1) {
4216 {
4217 arg2 = (int)(SWIG_As_int(obj1));
4218 if (SWIG_arg_fail(2)) SWIG_fail;
4219 }
4220 }
4221 {
4222 if (!wxPyCheckForApp()) SWIG_fail;
4223 PyThreadState* __tstate = wxPyBeginAllowThreads();
4224 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4225
4226 wxPyEndAllowThreads(__tstate);
4227 if (PyErr_Occurred()) SWIG_fail;
4228 }
4229 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4230 return resultobj;
4231 fail:
4232 return NULL;
4233 }
4234
4235
4236 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4237 PyObject *resultobj;
4238 PyObject *arg1 = (PyObject *) 0 ;
4239 wxBitmap *result;
4240 PyObject * obj0 = 0 ;
4241 char *kwnames[] = {
4242 (char *) "listOfStrings", NULL
4243 };
4244
4245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4246 arg1 = obj0;
4247 {
4248 if (!wxPyCheckForApp()) SWIG_fail;
4249 PyThreadState* __tstate = wxPyBeginAllowThreads();
4250 result = (wxBitmap *)new_wxBitmap(arg1);
4251
4252 wxPyEndAllowThreads(__tstate);
4253 if (PyErr_Occurred()) SWIG_fail;
4254 }
4255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4256 return resultobj;
4257 fail:
4258 return NULL;
4259 }
4260
4261
4262 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4263 PyObject *resultobj;
4264 PyObject *arg1 = (PyObject *) 0 ;
4265 int arg2 ;
4266 int arg3 ;
4267 int arg4 = (int) 1 ;
4268 wxBitmap *result;
4269 PyObject * obj0 = 0 ;
4270 PyObject * obj1 = 0 ;
4271 PyObject * obj2 = 0 ;
4272 PyObject * obj3 = 0 ;
4273 char *kwnames[] = {
4274 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4275 };
4276
4277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4278 arg1 = obj0;
4279 {
4280 arg2 = (int)(SWIG_As_int(obj1));
4281 if (SWIG_arg_fail(2)) SWIG_fail;
4282 }
4283 {
4284 arg3 = (int)(SWIG_As_int(obj2));
4285 if (SWIG_arg_fail(3)) SWIG_fail;
4286 }
4287 if (obj3) {
4288 {
4289 arg4 = (int)(SWIG_As_int(obj3));
4290 if (SWIG_arg_fail(4)) SWIG_fail;
4291 }
4292 }
4293 {
4294 if (!wxPyCheckForApp()) SWIG_fail;
4295 PyThreadState* __tstate = wxPyBeginAllowThreads();
4296 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4297
4298 wxPyEndAllowThreads(__tstate);
4299 if (PyErr_Occurred()) SWIG_fail;
4300 }
4301 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4302 return resultobj;
4303 fail:
4304 return NULL;
4305 }
4306
4307
4308 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4309 PyObject *resultobj;
4310 wxBitmap *arg1 = (wxBitmap *) 0 ;
4311 bool result;
4312 PyObject * obj0 = 0 ;
4313 char *kwnames[] = {
4314 (char *) "self", NULL
4315 };
4316
4317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4319 if (SWIG_arg_fail(1)) SWIG_fail;
4320 {
4321 PyThreadState* __tstate = wxPyBeginAllowThreads();
4322 result = (bool)(arg1)->Ok();
4323
4324 wxPyEndAllowThreads(__tstate);
4325 if (PyErr_Occurred()) SWIG_fail;
4326 }
4327 {
4328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4329 }
4330 return resultobj;
4331 fail:
4332 return NULL;
4333 }
4334
4335
4336 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4337 PyObject *resultobj;
4338 wxBitmap *arg1 = (wxBitmap *) 0 ;
4339 int result;
4340 PyObject * obj0 = 0 ;
4341 char *kwnames[] = {
4342 (char *) "self", NULL
4343 };
4344
4345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4347 if (SWIG_arg_fail(1)) SWIG_fail;
4348 {
4349 PyThreadState* __tstate = wxPyBeginAllowThreads();
4350 result = (int)(arg1)->GetWidth();
4351
4352 wxPyEndAllowThreads(__tstate);
4353 if (PyErr_Occurred()) SWIG_fail;
4354 }
4355 {
4356 resultobj = SWIG_From_int((int)(result));
4357 }
4358 return resultobj;
4359 fail:
4360 return NULL;
4361 }
4362
4363
4364 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4365 PyObject *resultobj;
4366 wxBitmap *arg1 = (wxBitmap *) 0 ;
4367 int result;
4368 PyObject * obj0 = 0 ;
4369 char *kwnames[] = {
4370 (char *) "self", NULL
4371 };
4372
4373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4375 if (SWIG_arg_fail(1)) SWIG_fail;
4376 {
4377 PyThreadState* __tstate = wxPyBeginAllowThreads();
4378 result = (int)(arg1)->GetHeight();
4379
4380 wxPyEndAllowThreads(__tstate);
4381 if (PyErr_Occurred()) SWIG_fail;
4382 }
4383 {
4384 resultobj = SWIG_From_int((int)(result));
4385 }
4386 return resultobj;
4387 fail:
4388 return NULL;
4389 }
4390
4391
4392 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4393 PyObject *resultobj;
4394 wxBitmap *arg1 = (wxBitmap *) 0 ;
4395 int result;
4396 PyObject * obj0 = 0 ;
4397 char *kwnames[] = {
4398 (char *) "self", NULL
4399 };
4400
4401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4403 if (SWIG_arg_fail(1)) SWIG_fail;
4404 {
4405 PyThreadState* __tstate = wxPyBeginAllowThreads();
4406 result = (int)(arg1)->GetDepth();
4407
4408 wxPyEndAllowThreads(__tstate);
4409 if (PyErr_Occurred()) SWIG_fail;
4410 }
4411 {
4412 resultobj = SWIG_From_int((int)(result));
4413 }
4414 return resultobj;
4415 fail:
4416 return NULL;
4417 }
4418
4419
4420 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4421 PyObject *resultobj;
4422 wxBitmap *arg1 = (wxBitmap *) 0 ;
4423 wxSize result;
4424 PyObject * obj0 = 0 ;
4425 char *kwnames[] = {
4426 (char *) "self", NULL
4427 };
4428
4429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4431 if (SWIG_arg_fail(1)) SWIG_fail;
4432 {
4433 PyThreadState* __tstate = wxPyBeginAllowThreads();
4434 result = wxBitmap_GetSize(arg1);
4435
4436 wxPyEndAllowThreads(__tstate);
4437 if (PyErr_Occurred()) SWIG_fail;
4438 }
4439 {
4440 wxSize * resultptr;
4441 resultptr = new wxSize((wxSize &)(result));
4442 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4443 }
4444 return resultobj;
4445 fail:
4446 return NULL;
4447 }
4448
4449
4450 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4451 PyObject *resultobj;
4452 wxBitmap *arg1 = (wxBitmap *) 0 ;
4453 SwigValueWrapper<wxImage > result;
4454 PyObject * obj0 = 0 ;
4455 char *kwnames[] = {
4456 (char *) "self", NULL
4457 };
4458
4459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4461 if (SWIG_arg_fail(1)) SWIG_fail;
4462 {
4463 PyThreadState* __tstate = wxPyBeginAllowThreads();
4464 result = ((wxBitmap const *)arg1)->ConvertToImage();
4465
4466 wxPyEndAllowThreads(__tstate);
4467 if (PyErr_Occurred()) SWIG_fail;
4468 }
4469 {
4470 wxImage * resultptr;
4471 resultptr = new wxImage((wxImage &)(result));
4472 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4473 }
4474 return resultobj;
4475 fail:
4476 return NULL;
4477 }
4478
4479
4480 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4481 PyObject *resultobj;
4482 wxBitmap *arg1 = (wxBitmap *) 0 ;
4483 wxMask *result;
4484 PyObject * obj0 = 0 ;
4485 char *kwnames[] = {
4486 (char *) "self", NULL
4487 };
4488
4489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4491 if (SWIG_arg_fail(1)) SWIG_fail;
4492 {
4493 PyThreadState* __tstate = wxPyBeginAllowThreads();
4494 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4495
4496 wxPyEndAllowThreads(__tstate);
4497 if (PyErr_Occurred()) SWIG_fail;
4498 }
4499 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4500 return resultobj;
4501 fail:
4502 return NULL;
4503 }
4504
4505
4506 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4507 PyObject *resultobj;
4508 wxBitmap *arg1 = (wxBitmap *) 0 ;
4509 wxMask *arg2 = (wxMask *) 0 ;
4510 PyObject * obj0 = 0 ;
4511 PyObject * obj1 = 0 ;
4512 char *kwnames[] = {
4513 (char *) "self",(char *) "mask", NULL
4514 };
4515
4516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4518 if (SWIG_arg_fail(1)) SWIG_fail;
4519 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4520 if (SWIG_arg_fail(2)) SWIG_fail;
4521 {
4522 PyThreadState* __tstate = wxPyBeginAllowThreads();
4523 (arg1)->SetMask(arg2);
4524
4525 wxPyEndAllowThreads(__tstate);
4526 if (PyErr_Occurred()) SWIG_fail;
4527 }
4528 Py_INCREF(Py_None); resultobj = Py_None;
4529 return resultobj;
4530 fail:
4531 return NULL;
4532 }
4533
4534
4535 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4536 PyObject *resultobj;
4537 wxBitmap *arg1 = (wxBitmap *) 0 ;
4538 wxColour *arg2 = 0 ;
4539 wxColour temp2 ;
4540 PyObject * obj0 = 0 ;
4541 PyObject * obj1 = 0 ;
4542 char *kwnames[] = {
4543 (char *) "self",(char *) "colour", NULL
4544 };
4545
4546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4548 if (SWIG_arg_fail(1)) SWIG_fail;
4549 {
4550 arg2 = &temp2;
4551 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4552 }
4553 {
4554 PyThreadState* __tstate = wxPyBeginAllowThreads();
4555 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4556
4557 wxPyEndAllowThreads(__tstate);
4558 if (PyErr_Occurred()) SWIG_fail;
4559 }
4560 Py_INCREF(Py_None); resultobj = Py_None;
4561 return resultobj;
4562 fail:
4563 return NULL;
4564 }
4565
4566
4567 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4568 PyObject *resultobj;
4569 wxBitmap *arg1 = (wxBitmap *) 0 ;
4570 wxRect *arg2 = 0 ;
4571 SwigValueWrapper<wxBitmap > result;
4572 wxRect temp2 ;
4573 PyObject * obj0 = 0 ;
4574 PyObject * obj1 = 0 ;
4575 char *kwnames[] = {
4576 (char *) "self",(char *) "rect", NULL
4577 };
4578
4579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4581 if (SWIG_arg_fail(1)) SWIG_fail;
4582 {
4583 arg2 = &temp2;
4584 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4585 }
4586 {
4587 PyThreadState* __tstate = wxPyBeginAllowThreads();
4588 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4589
4590 wxPyEndAllowThreads(__tstate);
4591 if (PyErr_Occurred()) SWIG_fail;
4592 }
4593 {
4594 wxBitmap * resultptr;
4595 resultptr = new wxBitmap((wxBitmap &)(result));
4596 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4597 }
4598 return resultobj;
4599 fail:
4600 return NULL;
4601 }
4602
4603
4604 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4605 PyObject *resultobj;
4606 wxBitmap *arg1 = (wxBitmap *) 0 ;
4607 wxString *arg2 = 0 ;
4608 wxBitmapType arg3 ;
4609 wxPalette *arg4 = (wxPalette *) NULL ;
4610 bool result;
4611 bool temp2 = false ;
4612 PyObject * obj0 = 0 ;
4613 PyObject * obj1 = 0 ;
4614 PyObject * obj2 = 0 ;
4615 PyObject * obj3 = 0 ;
4616 char *kwnames[] = {
4617 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4618 };
4619
4620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4622 if (SWIG_arg_fail(1)) SWIG_fail;
4623 {
4624 arg2 = wxString_in_helper(obj1);
4625 if (arg2 == NULL) SWIG_fail;
4626 temp2 = true;
4627 }
4628 {
4629 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4630 if (SWIG_arg_fail(3)) SWIG_fail;
4631 }
4632 if (obj3) {
4633 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4634 if (SWIG_arg_fail(4)) SWIG_fail;
4635 }
4636 {
4637 PyThreadState* __tstate = wxPyBeginAllowThreads();
4638 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4639
4640 wxPyEndAllowThreads(__tstate);
4641 if (PyErr_Occurred()) SWIG_fail;
4642 }
4643 {
4644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4645 }
4646 {
4647 if (temp2)
4648 delete arg2;
4649 }
4650 return resultobj;
4651 fail:
4652 {
4653 if (temp2)
4654 delete arg2;
4655 }
4656 return NULL;
4657 }
4658
4659
4660 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4661 PyObject *resultobj;
4662 wxBitmap *arg1 = (wxBitmap *) 0 ;
4663 wxString *arg2 = 0 ;
4664 wxBitmapType arg3 ;
4665 bool result;
4666 bool temp2 = false ;
4667 PyObject * obj0 = 0 ;
4668 PyObject * obj1 = 0 ;
4669 PyObject * obj2 = 0 ;
4670 char *kwnames[] = {
4671 (char *) "self",(char *) "name",(char *) "type", NULL
4672 };
4673
4674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4676 if (SWIG_arg_fail(1)) SWIG_fail;
4677 {
4678 arg2 = wxString_in_helper(obj1);
4679 if (arg2 == NULL) SWIG_fail;
4680 temp2 = true;
4681 }
4682 {
4683 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4684 if (SWIG_arg_fail(3)) SWIG_fail;
4685 }
4686 {
4687 PyThreadState* __tstate = wxPyBeginAllowThreads();
4688 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4689
4690 wxPyEndAllowThreads(__tstate);
4691 if (PyErr_Occurred()) SWIG_fail;
4692 }
4693 {
4694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4695 }
4696 {
4697 if (temp2)
4698 delete arg2;
4699 }
4700 return resultobj;
4701 fail:
4702 {
4703 if (temp2)
4704 delete arg2;
4705 }
4706 return NULL;
4707 }
4708
4709
4710 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4711 PyObject *resultobj;
4712 wxBitmap *arg1 = (wxBitmap *) 0 ;
4713 wxPalette *result;
4714 PyObject * obj0 = 0 ;
4715 char *kwnames[] = {
4716 (char *) "self", NULL
4717 };
4718
4719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4721 if (SWIG_arg_fail(1)) SWIG_fail;
4722 {
4723 PyThreadState* __tstate = wxPyBeginAllowThreads();
4724 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4725
4726 wxPyEndAllowThreads(__tstate);
4727 if (PyErr_Occurred()) SWIG_fail;
4728 }
4729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4730 return resultobj;
4731 fail:
4732 return NULL;
4733 }
4734
4735
4736 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4737 PyObject *resultobj;
4738 wxBitmap *arg1 = (wxBitmap *) 0 ;
4739 wxIcon *arg2 = 0 ;
4740 bool result;
4741 PyObject * obj0 = 0 ;
4742 PyObject * obj1 = 0 ;
4743 char *kwnames[] = {
4744 (char *) "self",(char *) "icon", NULL
4745 };
4746
4747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4749 if (SWIG_arg_fail(1)) SWIG_fail;
4750 {
4751 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4752 if (SWIG_arg_fail(2)) SWIG_fail;
4753 if (arg2 == NULL) {
4754 SWIG_null_ref("wxIcon");
4755 }
4756 if (SWIG_arg_fail(2)) SWIG_fail;
4757 }
4758 {
4759 PyThreadState* __tstate = wxPyBeginAllowThreads();
4760 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4761
4762 wxPyEndAllowThreads(__tstate);
4763 if (PyErr_Occurred()) SWIG_fail;
4764 }
4765 {
4766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4767 }
4768 return resultobj;
4769 fail:
4770 return NULL;
4771 }
4772
4773
4774 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4775 PyObject *resultobj;
4776 wxBitmap *arg1 = (wxBitmap *) 0 ;
4777 int arg2 ;
4778 PyObject * obj0 = 0 ;
4779 PyObject * obj1 = 0 ;
4780 char *kwnames[] = {
4781 (char *) "self",(char *) "height", NULL
4782 };
4783
4784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4786 if (SWIG_arg_fail(1)) SWIG_fail;
4787 {
4788 arg2 = (int)(SWIG_As_int(obj1));
4789 if (SWIG_arg_fail(2)) SWIG_fail;
4790 }
4791 {
4792 PyThreadState* __tstate = wxPyBeginAllowThreads();
4793 (arg1)->SetHeight(arg2);
4794
4795 wxPyEndAllowThreads(__tstate);
4796 if (PyErr_Occurred()) SWIG_fail;
4797 }
4798 Py_INCREF(Py_None); resultobj = Py_None;
4799 return resultobj;
4800 fail:
4801 return NULL;
4802 }
4803
4804
4805 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4806 PyObject *resultobj;
4807 wxBitmap *arg1 = (wxBitmap *) 0 ;
4808 int arg2 ;
4809 PyObject * obj0 = 0 ;
4810 PyObject * obj1 = 0 ;
4811 char *kwnames[] = {
4812 (char *) "self",(char *) "width", NULL
4813 };
4814
4815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4817 if (SWIG_arg_fail(1)) SWIG_fail;
4818 {
4819 arg2 = (int)(SWIG_As_int(obj1));
4820 if (SWIG_arg_fail(2)) SWIG_fail;
4821 }
4822 {
4823 PyThreadState* __tstate = wxPyBeginAllowThreads();
4824 (arg1)->SetWidth(arg2);
4825
4826 wxPyEndAllowThreads(__tstate);
4827 if (PyErr_Occurred()) SWIG_fail;
4828 }
4829 Py_INCREF(Py_None); resultobj = Py_None;
4830 return resultobj;
4831 fail:
4832 return NULL;
4833 }
4834
4835
4836 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4837 PyObject *resultobj;
4838 wxBitmap *arg1 = (wxBitmap *) 0 ;
4839 int arg2 ;
4840 PyObject * obj0 = 0 ;
4841 PyObject * obj1 = 0 ;
4842 char *kwnames[] = {
4843 (char *) "self",(char *) "depth", NULL
4844 };
4845
4846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4848 if (SWIG_arg_fail(1)) SWIG_fail;
4849 {
4850 arg2 = (int)(SWIG_As_int(obj1));
4851 if (SWIG_arg_fail(2)) SWIG_fail;
4852 }
4853 {
4854 PyThreadState* __tstate = wxPyBeginAllowThreads();
4855 (arg1)->SetDepth(arg2);
4856
4857 wxPyEndAllowThreads(__tstate);
4858 if (PyErr_Occurred()) SWIG_fail;
4859 }
4860 Py_INCREF(Py_None); resultobj = Py_None;
4861 return resultobj;
4862 fail:
4863 return NULL;
4864 }
4865
4866
4867 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4868 PyObject *resultobj;
4869 wxBitmap *arg1 = (wxBitmap *) 0 ;
4870 wxSize *arg2 = 0 ;
4871 wxSize temp2 ;
4872 PyObject * obj0 = 0 ;
4873 PyObject * obj1 = 0 ;
4874 char *kwnames[] = {
4875 (char *) "self",(char *) "size", NULL
4876 };
4877
4878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4880 if (SWIG_arg_fail(1)) SWIG_fail;
4881 {
4882 arg2 = &temp2;
4883 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4884 }
4885 {
4886 PyThreadState* __tstate = wxPyBeginAllowThreads();
4887 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4888
4889 wxPyEndAllowThreads(__tstate);
4890 if (PyErr_Occurred()) SWIG_fail;
4891 }
4892 Py_INCREF(Py_None); resultobj = Py_None;
4893 return resultobj;
4894 fail:
4895 return NULL;
4896 }
4897
4898
4899 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4900 PyObject *resultobj;
4901 wxBitmap *arg1 = (wxBitmap *) 0 ;
4902 wxBitmap *arg2 = (wxBitmap *) 0 ;
4903 bool result;
4904 PyObject * obj0 = 0 ;
4905 PyObject * obj1 = 0 ;
4906 char *kwnames[] = {
4907 (char *) "self",(char *) "other", NULL
4908 };
4909
4910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
4911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4912 if (SWIG_arg_fail(1)) SWIG_fail;
4913 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4914 if (SWIG_arg_fail(2)) SWIG_fail;
4915 {
4916 PyThreadState* __tstate = wxPyBeginAllowThreads();
4917 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
4918
4919 wxPyEndAllowThreads(__tstate);
4920 if (PyErr_Occurred()) SWIG_fail;
4921 }
4922 {
4923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4924 }
4925 return resultobj;
4926 fail:
4927 return NULL;
4928 }
4929
4930
4931 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4932 PyObject *resultobj;
4933 wxBitmap *arg1 = (wxBitmap *) 0 ;
4934 wxBitmap *arg2 = (wxBitmap *) 0 ;
4935 bool result;
4936 PyObject * obj0 = 0 ;
4937 PyObject * obj1 = 0 ;
4938 char *kwnames[] = {
4939 (char *) "self",(char *) "other", NULL
4940 };
4941
4942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
4943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4944 if (SWIG_arg_fail(1)) SWIG_fail;
4945 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4946 if (SWIG_arg_fail(2)) SWIG_fail;
4947 {
4948 PyThreadState* __tstate = wxPyBeginAllowThreads();
4949 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
4950
4951 wxPyEndAllowThreads(__tstate);
4952 if (PyErr_Occurred()) SWIG_fail;
4953 }
4954 {
4955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4956 }
4957 return resultobj;
4958 fail:
4959 return NULL;
4960 }
4961
4962
4963 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
4964 PyObject *obj;
4965 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4966 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
4967 Py_INCREF(obj);
4968 return Py_BuildValue((char *)"");
4969 }
4970 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
4971 PyObject *resultobj;
4972 wxBitmap *arg1 = 0 ;
4973 wxColour const &arg2_defvalue = wxNullColour ;
4974 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
4975 wxMask *result;
4976 wxColour temp2 ;
4977 PyObject * obj0 = 0 ;
4978 PyObject * obj1 = 0 ;
4979 char *kwnames[] = {
4980 (char *) "bitmap",(char *) "colour", NULL
4981 };
4982
4983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
4984 {
4985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4986 if (SWIG_arg_fail(1)) SWIG_fail;
4987 if (arg1 == NULL) {
4988 SWIG_null_ref("wxBitmap");
4989 }
4990 if (SWIG_arg_fail(1)) SWIG_fail;
4991 }
4992 if (obj1) {
4993 {
4994 arg2 = &temp2;
4995 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4996 }
4997 }
4998 {
4999 if (!wxPyCheckForApp()) SWIG_fail;
5000 PyThreadState* __tstate = wxPyBeginAllowThreads();
5001 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
5002
5003 wxPyEndAllowThreads(__tstate);
5004 if (PyErr_Occurred()) SWIG_fail;
5005 }
5006 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
5007 return resultobj;
5008 fail:
5009 return NULL;
5010 }
5011
5012
5013 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
5014 PyObject *obj;
5015 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5016 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
5017 Py_INCREF(obj);
5018 return Py_BuildValue((char *)"");
5019 }
5020 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5021 PyObject *resultobj;
5022 wxString *arg1 = 0 ;
5023 wxBitmapType arg2 ;
5024 int arg3 = (int) -1 ;
5025 int arg4 = (int) -1 ;
5026 wxIcon *result;
5027 bool temp1 = false ;
5028 PyObject * obj0 = 0 ;
5029 PyObject * obj1 = 0 ;
5030 PyObject * obj2 = 0 ;
5031 PyObject * obj3 = 0 ;
5032 char *kwnames[] = {
5033 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
5034 };
5035
5036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5037 {
5038 arg1 = wxString_in_helper(obj0);
5039 if (arg1 == NULL) SWIG_fail;
5040 temp1 = true;
5041 }
5042 {
5043 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
5044 if (SWIG_arg_fail(2)) SWIG_fail;
5045 }
5046 if (obj2) {
5047 {
5048 arg3 = (int)(SWIG_As_int(obj2));
5049 if (SWIG_arg_fail(3)) SWIG_fail;
5050 }
5051 }
5052 if (obj3) {
5053 {
5054 arg4 = (int)(SWIG_As_int(obj3));
5055 if (SWIG_arg_fail(4)) SWIG_fail;
5056 }
5057 }
5058 {
5059 if (!wxPyCheckForApp()) SWIG_fail;
5060 PyThreadState* __tstate = wxPyBeginAllowThreads();
5061 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
5062
5063 wxPyEndAllowThreads(__tstate);
5064 if (PyErr_Occurred()) SWIG_fail;
5065 }
5066 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5067 {
5068 if (temp1)
5069 delete arg1;
5070 }
5071 return resultobj;
5072 fail:
5073 {
5074 if (temp1)
5075 delete arg1;
5076 }
5077 return NULL;
5078 }
5079
5080
5081 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5082 PyObject *resultobj;
5083 wxIcon *arg1 = (wxIcon *) 0 ;
5084 PyObject * obj0 = 0 ;
5085 char *kwnames[] = {
5086 (char *) "self", NULL
5087 };
5088
5089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
5090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5091 if (SWIG_arg_fail(1)) SWIG_fail;
5092 {
5093 PyThreadState* __tstate = wxPyBeginAllowThreads();
5094 delete arg1;
5095
5096 wxPyEndAllowThreads(__tstate);
5097 if (PyErr_Occurred()) SWIG_fail;
5098 }
5099 Py_INCREF(Py_None); resultobj = Py_None;
5100 return resultobj;
5101 fail:
5102 return NULL;
5103 }
5104
5105
5106 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5107 PyObject *resultobj;
5108 wxIcon *result;
5109 char *kwnames[] = {
5110 NULL
5111 };
5112
5113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5114 {
5115 if (!wxPyCheckForApp()) SWIG_fail;
5116 PyThreadState* __tstate = wxPyBeginAllowThreads();
5117 result = (wxIcon *)new wxIcon();
5118
5119 wxPyEndAllowThreads(__tstate);
5120 if (PyErr_Occurred()) SWIG_fail;
5121 }
5122 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5123 return resultobj;
5124 fail:
5125 return NULL;
5126 }
5127
5128
5129 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5130 PyObject *resultobj;
5131 wxIconLocation *arg1 = 0 ;
5132 wxIcon *result;
5133 PyObject * obj0 = 0 ;
5134 char *kwnames[] = {
5135 (char *) "loc", NULL
5136 };
5137
5138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5139 {
5140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5141 if (SWIG_arg_fail(1)) SWIG_fail;
5142 if (arg1 == NULL) {
5143 SWIG_null_ref("wxIconLocation");
5144 }
5145 if (SWIG_arg_fail(1)) SWIG_fail;
5146 }
5147 {
5148 if (!wxPyCheckForApp()) SWIG_fail;
5149 PyThreadState* __tstate = wxPyBeginAllowThreads();
5150 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5151
5152 wxPyEndAllowThreads(__tstate);
5153 if (PyErr_Occurred()) SWIG_fail;
5154 }
5155 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5156 return resultobj;
5157 fail:
5158 return NULL;
5159 }
5160
5161
5162 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5163 PyObject *resultobj;
5164 wxBitmap *arg1 = 0 ;
5165 wxIcon *result;
5166 PyObject * obj0 = 0 ;
5167 char *kwnames[] = {
5168 (char *) "bmp", NULL
5169 };
5170
5171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5172 {
5173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5174 if (SWIG_arg_fail(1)) SWIG_fail;
5175 if (arg1 == NULL) {
5176 SWIG_null_ref("wxBitmap");
5177 }
5178 if (SWIG_arg_fail(1)) SWIG_fail;
5179 }
5180 {
5181 if (!wxPyCheckForApp()) SWIG_fail;
5182 PyThreadState* __tstate = wxPyBeginAllowThreads();
5183 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5184
5185 wxPyEndAllowThreads(__tstate);
5186 if (PyErr_Occurred()) SWIG_fail;
5187 }
5188 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5189 return resultobj;
5190 fail:
5191 return NULL;
5192 }
5193
5194
5195 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5196 PyObject *resultobj;
5197 PyObject *arg1 = (PyObject *) 0 ;
5198 wxIcon *result;
5199 PyObject * obj0 = 0 ;
5200 char *kwnames[] = {
5201 (char *) "listOfStrings", NULL
5202 };
5203
5204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5205 arg1 = obj0;
5206 {
5207 if (!wxPyCheckForApp()) SWIG_fail;
5208 PyThreadState* __tstate = wxPyBeginAllowThreads();
5209 result = (wxIcon *)new_wxIcon(arg1);
5210
5211 wxPyEndAllowThreads(__tstate);
5212 if (PyErr_Occurred()) SWIG_fail;
5213 }
5214 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5215 return resultobj;
5216 fail:
5217 return NULL;
5218 }
5219
5220
5221 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5222 PyObject *resultobj;
5223 wxIcon *arg1 = (wxIcon *) 0 ;
5224 bool result;
5225 PyObject * obj0 = 0 ;
5226 char *kwnames[] = {
5227 (char *) "self", NULL
5228 };
5229
5230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5232 if (SWIG_arg_fail(1)) SWIG_fail;
5233 {
5234 PyThreadState* __tstate = wxPyBeginAllowThreads();
5235 result = (bool)(arg1)->Ok();
5236
5237 wxPyEndAllowThreads(__tstate);
5238 if (PyErr_Occurred()) SWIG_fail;
5239 }
5240 {
5241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5242 }
5243 return resultobj;
5244 fail:
5245 return NULL;
5246 }
5247
5248
5249 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5250 PyObject *resultobj;
5251 wxIcon *arg1 = (wxIcon *) 0 ;
5252 int result;
5253 PyObject * obj0 = 0 ;
5254 char *kwnames[] = {
5255 (char *) "self", NULL
5256 };
5257
5258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5260 if (SWIG_arg_fail(1)) SWIG_fail;
5261 {
5262 PyThreadState* __tstate = wxPyBeginAllowThreads();
5263 result = (int)(arg1)->GetWidth();
5264
5265 wxPyEndAllowThreads(__tstate);
5266 if (PyErr_Occurred()) SWIG_fail;
5267 }
5268 {
5269 resultobj = SWIG_From_int((int)(result));
5270 }
5271 return resultobj;
5272 fail:
5273 return NULL;
5274 }
5275
5276
5277 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5278 PyObject *resultobj;
5279 wxIcon *arg1 = (wxIcon *) 0 ;
5280 int result;
5281 PyObject * obj0 = 0 ;
5282 char *kwnames[] = {
5283 (char *) "self", NULL
5284 };
5285
5286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5288 if (SWIG_arg_fail(1)) SWIG_fail;
5289 {
5290 PyThreadState* __tstate = wxPyBeginAllowThreads();
5291 result = (int)(arg1)->GetHeight();
5292
5293 wxPyEndAllowThreads(__tstate);
5294 if (PyErr_Occurred()) SWIG_fail;
5295 }
5296 {
5297 resultobj = SWIG_From_int((int)(result));
5298 }
5299 return resultobj;
5300 fail:
5301 return NULL;
5302 }
5303
5304
5305 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5306 PyObject *resultobj;
5307 wxIcon *arg1 = (wxIcon *) 0 ;
5308 int result;
5309 PyObject * obj0 = 0 ;
5310 char *kwnames[] = {
5311 (char *) "self", NULL
5312 };
5313
5314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5316 if (SWIG_arg_fail(1)) SWIG_fail;
5317 {
5318 PyThreadState* __tstate = wxPyBeginAllowThreads();
5319 result = (int)(arg1)->GetDepth();
5320
5321 wxPyEndAllowThreads(__tstate);
5322 if (PyErr_Occurred()) SWIG_fail;
5323 }
5324 {
5325 resultobj = SWIG_From_int((int)(result));
5326 }
5327 return resultobj;
5328 fail:
5329 return NULL;
5330 }
5331
5332
5333 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5334 PyObject *resultobj;
5335 wxIcon *arg1 = (wxIcon *) 0 ;
5336 int arg2 ;
5337 PyObject * obj0 = 0 ;
5338 PyObject * obj1 = 0 ;
5339 char *kwnames[] = {
5340 (char *) "self",(char *) "w", NULL
5341 };
5342
5343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5345 if (SWIG_arg_fail(1)) SWIG_fail;
5346 {
5347 arg2 = (int)(SWIG_As_int(obj1));
5348 if (SWIG_arg_fail(2)) SWIG_fail;
5349 }
5350 {
5351 PyThreadState* __tstate = wxPyBeginAllowThreads();
5352 (arg1)->SetWidth(arg2);
5353
5354 wxPyEndAllowThreads(__tstate);
5355 if (PyErr_Occurred()) SWIG_fail;
5356 }
5357 Py_INCREF(Py_None); resultobj = Py_None;
5358 return resultobj;
5359 fail:
5360 return NULL;
5361 }
5362
5363
5364 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5365 PyObject *resultobj;
5366 wxIcon *arg1 = (wxIcon *) 0 ;
5367 int arg2 ;
5368 PyObject * obj0 = 0 ;
5369 PyObject * obj1 = 0 ;
5370 char *kwnames[] = {
5371 (char *) "self",(char *) "h", NULL
5372 };
5373
5374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5376 if (SWIG_arg_fail(1)) SWIG_fail;
5377 {
5378 arg2 = (int)(SWIG_As_int(obj1));
5379 if (SWIG_arg_fail(2)) SWIG_fail;
5380 }
5381 {
5382 PyThreadState* __tstate = wxPyBeginAllowThreads();
5383 (arg1)->SetHeight(arg2);
5384
5385 wxPyEndAllowThreads(__tstate);
5386 if (PyErr_Occurred()) SWIG_fail;
5387 }
5388 Py_INCREF(Py_None); resultobj = Py_None;
5389 return resultobj;
5390 fail:
5391 return NULL;
5392 }
5393
5394
5395 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5396 PyObject *resultobj;
5397 wxIcon *arg1 = (wxIcon *) 0 ;
5398 int arg2 ;
5399 PyObject * obj0 = 0 ;
5400 PyObject * obj1 = 0 ;
5401 char *kwnames[] = {
5402 (char *) "self",(char *) "d", NULL
5403 };
5404
5405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5407 if (SWIG_arg_fail(1)) SWIG_fail;
5408 {
5409 arg2 = (int)(SWIG_As_int(obj1));
5410 if (SWIG_arg_fail(2)) SWIG_fail;
5411 }
5412 {
5413 PyThreadState* __tstate = wxPyBeginAllowThreads();
5414 (arg1)->SetDepth(arg2);
5415
5416 wxPyEndAllowThreads(__tstate);
5417 if (PyErr_Occurred()) SWIG_fail;
5418 }
5419 Py_INCREF(Py_None); resultobj = Py_None;
5420 return resultobj;
5421 fail:
5422 return NULL;
5423 }
5424
5425
5426 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5427 PyObject *resultobj;
5428 wxIcon *arg1 = (wxIcon *) 0 ;
5429 wxBitmap *arg2 = 0 ;
5430 PyObject * obj0 = 0 ;
5431 PyObject * obj1 = 0 ;
5432 char *kwnames[] = {
5433 (char *) "self",(char *) "bmp", NULL
5434 };
5435
5436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5438 if (SWIG_arg_fail(1)) SWIG_fail;
5439 {
5440 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5441 if (SWIG_arg_fail(2)) SWIG_fail;
5442 if (arg2 == NULL) {
5443 SWIG_null_ref("wxBitmap");
5444 }
5445 if (SWIG_arg_fail(2)) SWIG_fail;
5446 }
5447 {
5448 PyThreadState* __tstate = wxPyBeginAllowThreads();
5449 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5450
5451 wxPyEndAllowThreads(__tstate);
5452 if (PyErr_Occurred()) SWIG_fail;
5453 }
5454 Py_INCREF(Py_None); resultobj = Py_None;
5455 return resultobj;
5456 fail:
5457 return NULL;
5458 }
5459
5460
5461 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5462 PyObject *obj;
5463 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5464 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5465 Py_INCREF(obj);
5466 return Py_BuildValue((char *)"");
5467 }
5468 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5469 PyObject *resultobj;
5470 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5471 int arg2 = (int) 0 ;
5472 wxIconLocation *result;
5473 bool temp1 = false ;
5474 PyObject * obj0 = 0 ;
5475 PyObject * obj1 = 0 ;
5476 char *kwnames[] = {
5477 (char *) "filename",(char *) "num", NULL
5478 };
5479
5480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5481 if (obj0) {
5482 {
5483 arg1 = wxString_in_helper(obj0);
5484 if (arg1 == NULL) SWIG_fail;
5485 temp1 = true;
5486 }
5487 }
5488 if (obj1) {
5489 {
5490 arg2 = (int)(SWIG_As_int(obj1));
5491 if (SWIG_arg_fail(2)) SWIG_fail;
5492 }
5493 }
5494 {
5495 PyThreadState* __tstate = wxPyBeginAllowThreads();
5496 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5497
5498 wxPyEndAllowThreads(__tstate);
5499 if (PyErr_Occurred()) SWIG_fail;
5500 }
5501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5502 {
5503 if (temp1)
5504 delete arg1;
5505 }
5506 return resultobj;
5507 fail:
5508 {
5509 if (temp1)
5510 delete arg1;
5511 }
5512 return NULL;
5513 }
5514
5515
5516 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5517 PyObject *resultobj;
5518 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5519 PyObject * obj0 = 0 ;
5520 char *kwnames[] = {
5521 (char *) "self", NULL
5522 };
5523
5524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5526 if (SWIG_arg_fail(1)) SWIG_fail;
5527 {
5528 PyThreadState* __tstate = wxPyBeginAllowThreads();
5529 delete arg1;
5530
5531 wxPyEndAllowThreads(__tstate);
5532 if (PyErr_Occurred()) SWIG_fail;
5533 }
5534 Py_INCREF(Py_None); resultobj = Py_None;
5535 return resultobj;
5536 fail:
5537 return NULL;
5538 }
5539
5540
5541 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5542 PyObject *resultobj;
5543 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5544 bool result;
5545 PyObject * obj0 = 0 ;
5546 char *kwnames[] = {
5547 (char *) "self", NULL
5548 };
5549
5550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5552 if (SWIG_arg_fail(1)) SWIG_fail;
5553 {
5554 PyThreadState* __tstate = wxPyBeginAllowThreads();
5555 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5556
5557 wxPyEndAllowThreads(__tstate);
5558 if (PyErr_Occurred()) SWIG_fail;
5559 }
5560 {
5561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5562 }
5563 return resultobj;
5564 fail:
5565 return NULL;
5566 }
5567
5568
5569 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5570 PyObject *resultobj;
5571 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5572 wxString *arg2 = 0 ;
5573 bool temp2 = false ;
5574 PyObject * obj0 = 0 ;
5575 PyObject * obj1 = 0 ;
5576 char *kwnames[] = {
5577 (char *) "self",(char *) "filename", NULL
5578 };
5579
5580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5582 if (SWIG_arg_fail(1)) SWIG_fail;
5583 {
5584 arg2 = wxString_in_helper(obj1);
5585 if (arg2 == NULL) SWIG_fail;
5586 temp2 = true;
5587 }
5588 {
5589 PyThreadState* __tstate = wxPyBeginAllowThreads();
5590 (arg1)->SetFileName((wxString const &)*arg2);
5591
5592 wxPyEndAllowThreads(__tstate);
5593 if (PyErr_Occurred()) SWIG_fail;
5594 }
5595 Py_INCREF(Py_None); resultobj = Py_None;
5596 {
5597 if (temp2)
5598 delete arg2;
5599 }
5600 return resultobj;
5601 fail:
5602 {
5603 if (temp2)
5604 delete arg2;
5605 }
5606 return NULL;
5607 }
5608
5609
5610 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5611 PyObject *resultobj;
5612 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5613 wxString *result;
5614 PyObject * obj0 = 0 ;
5615 char *kwnames[] = {
5616 (char *) "self", NULL
5617 };
5618
5619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5621 if (SWIG_arg_fail(1)) SWIG_fail;
5622 {
5623 PyThreadState* __tstate = wxPyBeginAllowThreads();
5624 {
5625 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5626 result = (wxString *) &_result_ref;
5627 }
5628
5629 wxPyEndAllowThreads(__tstate);
5630 if (PyErr_Occurred()) SWIG_fail;
5631 }
5632 {
5633 #if wxUSE_UNICODE
5634 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5635 #else
5636 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5637 #endif
5638 }
5639 return resultobj;
5640 fail:
5641 return NULL;
5642 }
5643
5644
5645 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5646 PyObject *resultobj;
5647 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5648 int arg2 ;
5649 PyObject * obj0 = 0 ;
5650 PyObject * obj1 = 0 ;
5651 char *kwnames[] = {
5652 (char *) "self",(char *) "num", NULL
5653 };
5654
5655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5657 if (SWIG_arg_fail(1)) SWIG_fail;
5658 {
5659 arg2 = (int)(SWIG_As_int(obj1));
5660 if (SWIG_arg_fail(2)) SWIG_fail;
5661 }
5662 {
5663 PyThreadState* __tstate = wxPyBeginAllowThreads();
5664 wxIconLocation_SetIndex(arg1,arg2);
5665
5666 wxPyEndAllowThreads(__tstate);
5667 if (PyErr_Occurred()) SWIG_fail;
5668 }
5669 Py_INCREF(Py_None); resultobj = Py_None;
5670 return resultobj;
5671 fail:
5672 return NULL;
5673 }
5674
5675
5676 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5677 PyObject *resultobj;
5678 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5679 int result;
5680 PyObject * obj0 = 0 ;
5681 char *kwnames[] = {
5682 (char *) "self", NULL
5683 };
5684
5685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5687 if (SWIG_arg_fail(1)) SWIG_fail;
5688 {
5689 PyThreadState* __tstate = wxPyBeginAllowThreads();
5690 result = (int)wxIconLocation_GetIndex(arg1);
5691
5692 wxPyEndAllowThreads(__tstate);
5693 if (PyErr_Occurred()) SWIG_fail;
5694 }
5695 {
5696 resultobj = SWIG_From_int((int)(result));
5697 }
5698 return resultobj;
5699 fail:
5700 return NULL;
5701 }
5702
5703
5704 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5705 PyObject *obj;
5706 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5707 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5708 Py_INCREF(obj);
5709 return Py_BuildValue((char *)"");
5710 }
5711 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5712 PyObject *resultobj;
5713 wxIconBundle *result;
5714 char *kwnames[] = {
5715 NULL
5716 };
5717
5718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5719 {
5720 PyThreadState* __tstate = wxPyBeginAllowThreads();
5721 result = (wxIconBundle *)new wxIconBundle();
5722
5723 wxPyEndAllowThreads(__tstate);
5724 if (PyErr_Occurred()) SWIG_fail;
5725 }
5726 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5727 return resultobj;
5728 fail:
5729 return NULL;
5730 }
5731
5732
5733 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5734 PyObject *resultobj;
5735 wxString *arg1 = 0 ;
5736 long arg2 ;
5737 wxIconBundle *result;
5738 bool temp1 = false ;
5739 PyObject * obj0 = 0 ;
5740 PyObject * obj1 = 0 ;
5741 char *kwnames[] = {
5742 (char *) "file",(char *) "type", NULL
5743 };
5744
5745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
5746 {
5747 arg1 = wxString_in_helper(obj0);
5748 if (arg1 == NULL) SWIG_fail;
5749 temp1 = true;
5750 }
5751 {
5752 arg2 = (long)(SWIG_As_long(obj1));
5753 if (SWIG_arg_fail(2)) SWIG_fail;
5754 }
5755 {
5756 PyThreadState* __tstate = wxPyBeginAllowThreads();
5757 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
5758
5759 wxPyEndAllowThreads(__tstate);
5760 if (PyErr_Occurred()) SWIG_fail;
5761 }
5762 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5763 {
5764 if (temp1)
5765 delete arg1;
5766 }
5767 return resultobj;
5768 fail:
5769 {
5770 if (temp1)
5771 delete arg1;
5772 }
5773 return NULL;
5774 }
5775
5776
5777 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5778 PyObject *resultobj;
5779 wxIcon *arg1 = 0 ;
5780 wxIconBundle *result;
5781 PyObject * obj0 = 0 ;
5782 char *kwnames[] = {
5783 (char *) "icon", NULL
5784 };
5785
5786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
5787 {
5788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5789 if (SWIG_arg_fail(1)) SWIG_fail;
5790 if (arg1 == NULL) {
5791 SWIG_null_ref("wxIcon");
5792 }
5793 if (SWIG_arg_fail(1)) SWIG_fail;
5794 }
5795 {
5796 PyThreadState* __tstate = wxPyBeginAllowThreads();
5797 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
5798
5799 wxPyEndAllowThreads(__tstate);
5800 if (PyErr_Occurred()) SWIG_fail;
5801 }
5802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5803 return resultobj;
5804 fail:
5805 return NULL;
5806 }
5807
5808
5809 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5810 PyObject *resultobj;
5811 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5812 PyObject * obj0 = 0 ;
5813 char *kwnames[] = {
5814 (char *) "self", NULL
5815 };
5816
5817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
5818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5819 if (SWIG_arg_fail(1)) SWIG_fail;
5820 {
5821 PyThreadState* __tstate = wxPyBeginAllowThreads();
5822 delete arg1;
5823
5824 wxPyEndAllowThreads(__tstate);
5825 if (PyErr_Occurred()) SWIG_fail;
5826 }
5827 Py_INCREF(Py_None); resultobj = Py_None;
5828 return resultobj;
5829 fail:
5830 return NULL;
5831 }
5832
5833
5834 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5835 PyObject *resultobj;
5836 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5837 wxIcon *arg2 = 0 ;
5838 PyObject * obj0 = 0 ;
5839 PyObject * obj1 = 0 ;
5840 char *kwnames[] = {
5841 (char *) "self",(char *) "icon", NULL
5842 };
5843
5844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
5845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5846 if (SWIG_arg_fail(1)) SWIG_fail;
5847 {
5848 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5849 if (SWIG_arg_fail(2)) SWIG_fail;
5850 if (arg2 == NULL) {
5851 SWIG_null_ref("wxIcon");
5852 }
5853 if (SWIG_arg_fail(2)) SWIG_fail;
5854 }
5855 {
5856 PyThreadState* __tstate = wxPyBeginAllowThreads();
5857 (arg1)->AddIcon((wxIcon const &)*arg2);
5858
5859 wxPyEndAllowThreads(__tstate);
5860 if (PyErr_Occurred()) SWIG_fail;
5861 }
5862 Py_INCREF(Py_None); resultobj = Py_None;
5863 return resultobj;
5864 fail:
5865 return NULL;
5866 }
5867
5868
5869 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5870 PyObject *resultobj;
5871 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5872 wxString *arg2 = 0 ;
5873 long arg3 ;
5874 bool temp2 = false ;
5875 PyObject * obj0 = 0 ;
5876 PyObject * obj1 = 0 ;
5877 PyObject * obj2 = 0 ;
5878 char *kwnames[] = {
5879 (char *) "self",(char *) "file",(char *) "type", NULL
5880 };
5881
5882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5884 if (SWIG_arg_fail(1)) SWIG_fail;
5885 {
5886 arg2 = wxString_in_helper(obj1);
5887 if (arg2 == NULL) SWIG_fail;
5888 temp2 = true;
5889 }
5890 {
5891 arg3 = (long)(SWIG_As_long(obj2));
5892 if (SWIG_arg_fail(3)) SWIG_fail;
5893 }
5894 {
5895 PyThreadState* __tstate = wxPyBeginAllowThreads();
5896 (arg1)->AddIcon((wxString const &)*arg2,arg3);
5897
5898 wxPyEndAllowThreads(__tstate);
5899 if (PyErr_Occurred()) SWIG_fail;
5900 }
5901 Py_INCREF(Py_None); resultobj = Py_None;
5902 {
5903 if (temp2)
5904 delete arg2;
5905 }
5906 return resultobj;
5907 fail:
5908 {
5909 if (temp2)
5910 delete arg2;
5911 }
5912 return NULL;
5913 }
5914
5915
5916 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5917 PyObject *resultobj;
5918 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5919 wxSize *arg2 = 0 ;
5920 wxIcon *result;
5921 wxSize temp2 ;
5922 PyObject * obj0 = 0 ;
5923 PyObject * obj1 = 0 ;
5924 char *kwnames[] = {
5925 (char *) "self",(char *) "size", NULL
5926 };
5927
5928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
5929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5930 if (SWIG_arg_fail(1)) SWIG_fail;
5931 {
5932 arg2 = &temp2;
5933 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5934 }
5935 {
5936 PyThreadState* __tstate = wxPyBeginAllowThreads();
5937 {
5938 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
5939 result = (wxIcon *) &_result_ref;
5940 }
5941
5942 wxPyEndAllowThreads(__tstate);
5943 if (PyErr_Occurred()) SWIG_fail;
5944 }
5945 {
5946 wxIcon* resultptr = new wxIcon(*result);
5947 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
5948 }
5949 return resultobj;
5950 fail:
5951 return NULL;
5952 }
5953
5954
5955 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
5956 PyObject *obj;
5957 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5958 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
5959 Py_INCREF(obj);
5960 return Py_BuildValue((char *)"");
5961 }
5962 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5963 PyObject *resultobj;
5964 wxString *arg1 = 0 ;
5965 long arg2 ;
5966 int arg3 = (int) 0 ;
5967 int arg4 = (int) 0 ;
5968 wxCursor *result;
5969 bool temp1 = false ;
5970 PyObject * obj0 = 0 ;
5971 PyObject * obj1 = 0 ;
5972 PyObject * obj2 = 0 ;
5973 PyObject * obj3 = 0 ;
5974 char *kwnames[] = {
5975 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
5976 };
5977
5978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5979 {
5980 arg1 = wxString_in_helper(obj0);
5981 if (arg1 == NULL) SWIG_fail;
5982 temp1 = true;
5983 }
5984 {
5985 arg2 = (long)(SWIG_As_long(obj1));
5986 if (SWIG_arg_fail(2)) SWIG_fail;
5987 }
5988 if (obj2) {
5989 {
5990 arg3 = (int)(SWIG_As_int(obj2));
5991 if (SWIG_arg_fail(3)) SWIG_fail;
5992 }
5993 }
5994 if (obj3) {
5995 {
5996 arg4 = (int)(SWIG_As_int(obj3));
5997 if (SWIG_arg_fail(4)) SWIG_fail;
5998 }
5999 }
6000 {
6001 if (!wxPyCheckForApp()) SWIG_fail;
6002 PyThreadState* __tstate = wxPyBeginAllowThreads();
6003 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
6004
6005 wxPyEndAllowThreads(__tstate);
6006 if (PyErr_Occurred()) SWIG_fail;
6007 }
6008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6009 {
6010 if (temp1)
6011 delete arg1;
6012 }
6013 return resultobj;
6014 fail:
6015 {
6016 if (temp1)
6017 delete arg1;
6018 }
6019 return NULL;
6020 }
6021
6022
6023 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6024 PyObject *resultobj;
6025 wxCursor *arg1 = (wxCursor *) 0 ;
6026 PyObject * obj0 = 0 ;
6027 char *kwnames[] = {
6028 (char *) "self", NULL
6029 };
6030
6031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
6032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6033 if (SWIG_arg_fail(1)) SWIG_fail;
6034 {
6035 PyThreadState* __tstate = wxPyBeginAllowThreads();
6036 delete arg1;
6037
6038 wxPyEndAllowThreads(__tstate);
6039 if (PyErr_Occurred()) SWIG_fail;
6040 }
6041 Py_INCREF(Py_None); resultobj = Py_None;
6042 return resultobj;
6043 fail:
6044 return NULL;
6045 }
6046
6047
6048 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6049 PyObject *resultobj;
6050 int arg1 ;
6051 wxCursor *result;
6052 PyObject * obj0 = 0 ;
6053 char *kwnames[] = {
6054 (char *) "id", NULL
6055 };
6056
6057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
6058 {
6059 arg1 = (int)(SWIG_As_int(obj0));
6060 if (SWIG_arg_fail(1)) SWIG_fail;
6061 }
6062 {
6063 if (!wxPyCheckForApp()) SWIG_fail;
6064 PyThreadState* __tstate = wxPyBeginAllowThreads();
6065 result = (wxCursor *)new wxCursor(arg1);
6066
6067 wxPyEndAllowThreads(__tstate);
6068 if (PyErr_Occurred()) SWIG_fail;
6069 }
6070 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6071 return resultobj;
6072 fail:
6073 return NULL;
6074 }
6075
6076
6077 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6078 PyObject *resultobj;
6079 wxImage *arg1 = 0 ;
6080 wxCursor *result;
6081 PyObject * obj0 = 0 ;
6082 char *kwnames[] = {
6083 (char *) "image", NULL
6084 };
6085
6086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6087 {
6088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6089 if (SWIG_arg_fail(1)) SWIG_fail;
6090 if (arg1 == NULL) {
6091 SWIG_null_ref("wxImage");
6092 }
6093 if (SWIG_arg_fail(1)) SWIG_fail;
6094 }
6095 {
6096 if (!wxPyCheckForApp()) SWIG_fail;
6097 PyThreadState* __tstate = wxPyBeginAllowThreads();
6098 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6099
6100 wxPyEndAllowThreads(__tstate);
6101 if (PyErr_Occurred()) SWIG_fail;
6102 }
6103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6104 return resultobj;
6105 fail:
6106 return NULL;
6107 }
6108
6109
6110 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6111 PyObject *resultobj;
6112 wxCursor *arg1 = (wxCursor *) 0 ;
6113 bool result;
6114 PyObject * obj0 = 0 ;
6115 char *kwnames[] = {
6116 (char *) "self", NULL
6117 };
6118
6119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6121 if (SWIG_arg_fail(1)) SWIG_fail;
6122 {
6123 PyThreadState* __tstate = wxPyBeginAllowThreads();
6124 result = (bool)(arg1)->Ok();
6125
6126 wxPyEndAllowThreads(__tstate);
6127 if (PyErr_Occurred()) SWIG_fail;
6128 }
6129 {
6130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6131 }
6132 return resultobj;
6133 fail:
6134 return NULL;
6135 }
6136
6137
6138 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6139 PyObject *obj;
6140 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6141 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6142 Py_INCREF(obj);
6143 return Py_BuildValue((char *)"");
6144 }
6145 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6146 PyObject *resultobj;
6147 int arg1 = (int) 0 ;
6148 int arg2 = (int) 0 ;
6149 int arg3 = (int) 0 ;
6150 int arg4 = (int) 0 ;
6151 wxRegion *result;
6152 PyObject * obj0 = 0 ;
6153 PyObject * obj1 = 0 ;
6154 PyObject * obj2 = 0 ;
6155 PyObject * obj3 = 0 ;
6156 char *kwnames[] = {
6157 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6158 };
6159
6160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6161 if (obj0) {
6162 {
6163 arg1 = (int)(SWIG_As_int(obj0));
6164 if (SWIG_arg_fail(1)) SWIG_fail;
6165 }
6166 }
6167 if (obj1) {
6168 {
6169 arg2 = (int)(SWIG_As_int(obj1));
6170 if (SWIG_arg_fail(2)) SWIG_fail;
6171 }
6172 }
6173 if (obj2) {
6174 {
6175 arg3 = (int)(SWIG_As_int(obj2));
6176 if (SWIG_arg_fail(3)) SWIG_fail;
6177 }
6178 }
6179 if (obj3) {
6180 {
6181 arg4 = (int)(SWIG_As_int(obj3));
6182 if (SWIG_arg_fail(4)) SWIG_fail;
6183 }
6184 }
6185 {
6186 if (!wxPyCheckForApp()) SWIG_fail;
6187 PyThreadState* __tstate = wxPyBeginAllowThreads();
6188 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6189
6190 wxPyEndAllowThreads(__tstate);
6191 if (PyErr_Occurred()) SWIG_fail;
6192 }
6193 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6194 return resultobj;
6195 fail:
6196 return NULL;
6197 }
6198
6199
6200 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6201 PyObject *resultobj;
6202 wxBitmap *arg1 = 0 ;
6203 wxRegion *result;
6204 PyObject * obj0 = 0 ;
6205 char *kwnames[] = {
6206 (char *) "bmp", NULL
6207 };
6208
6209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6210 {
6211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6212 if (SWIG_arg_fail(1)) SWIG_fail;
6213 if (arg1 == NULL) {
6214 SWIG_null_ref("wxBitmap");
6215 }
6216 if (SWIG_arg_fail(1)) SWIG_fail;
6217 }
6218 {
6219 if (!wxPyCheckForApp()) SWIG_fail;
6220 PyThreadState* __tstate = wxPyBeginAllowThreads();
6221 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6222
6223 wxPyEndAllowThreads(__tstate);
6224 if (PyErr_Occurred()) SWIG_fail;
6225 }
6226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6227 return resultobj;
6228 fail:
6229 return NULL;
6230 }
6231
6232
6233 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6234 PyObject *resultobj;
6235 wxBitmap *arg1 = 0 ;
6236 wxColour *arg2 = 0 ;
6237 int arg3 = (int) 0 ;
6238 wxRegion *result;
6239 wxColour temp2 ;
6240 PyObject * obj0 = 0 ;
6241 PyObject * obj1 = 0 ;
6242 PyObject * obj2 = 0 ;
6243 char *kwnames[] = {
6244 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6245 };
6246
6247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6248 {
6249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6250 if (SWIG_arg_fail(1)) SWIG_fail;
6251 if (arg1 == NULL) {
6252 SWIG_null_ref("wxBitmap");
6253 }
6254 if (SWIG_arg_fail(1)) SWIG_fail;
6255 }
6256 {
6257 arg2 = &temp2;
6258 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6259 }
6260 if (obj2) {
6261 {
6262 arg3 = (int)(SWIG_As_int(obj2));
6263 if (SWIG_arg_fail(3)) SWIG_fail;
6264 }
6265 }
6266 {
6267 if (!wxPyCheckForApp()) SWIG_fail;
6268 PyThreadState* __tstate = wxPyBeginAllowThreads();
6269 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6270
6271 wxPyEndAllowThreads(__tstate);
6272 if (PyErr_Occurred()) SWIG_fail;
6273 }
6274 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6275 return resultobj;
6276 fail:
6277 return NULL;
6278 }
6279
6280
6281 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6282 PyObject *resultobj;
6283 int arg1 ;
6284 wxPoint *arg2 = (wxPoint *) 0 ;
6285 int arg3 = (int) wxWINDING_RULE ;
6286 wxRegion *result;
6287 PyObject * obj0 = 0 ;
6288 PyObject * obj1 = 0 ;
6289 char *kwnames[] = {
6290 (char *) "points",(char *) "fillStyle", NULL
6291 };
6292
6293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6294 {
6295 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6296 if (arg2 == NULL) SWIG_fail;
6297 }
6298 if (obj1) {
6299 {
6300 arg3 = (int)(SWIG_As_int(obj1));
6301 if (SWIG_arg_fail(3)) SWIG_fail;
6302 }
6303 }
6304 {
6305 if (!wxPyCheckForApp()) SWIG_fail;
6306 PyThreadState* __tstate = wxPyBeginAllowThreads();
6307 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6308
6309 wxPyEndAllowThreads(__tstate);
6310 if (PyErr_Occurred()) SWIG_fail;
6311 }
6312 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6313 {
6314 if (arg2) delete [] arg2;
6315 }
6316 return resultobj;
6317 fail:
6318 {
6319 if (arg2) delete [] arg2;
6320 }
6321 return NULL;
6322 }
6323
6324
6325 static PyObject *_wrap_delete_Region(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:delete_Region",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 delete arg1;
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_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6351 PyObject *resultobj;
6352 wxRegion *arg1 = (wxRegion *) 0 ;
6353 PyObject * obj0 = 0 ;
6354 char *kwnames[] = {
6355 (char *) "self", NULL
6356 };
6357
6358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6360 if (SWIG_arg_fail(1)) SWIG_fail;
6361 {
6362 PyThreadState* __tstate = wxPyBeginAllowThreads();
6363 (arg1)->Clear();
6364
6365 wxPyEndAllowThreads(__tstate);
6366 if (PyErr_Occurred()) SWIG_fail;
6367 }
6368 Py_INCREF(Py_None); resultobj = Py_None;
6369 return resultobj;
6370 fail:
6371 return NULL;
6372 }
6373
6374
6375 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6376 PyObject *resultobj;
6377 wxRegion *arg1 = (wxRegion *) 0 ;
6378 int arg2 ;
6379 int arg3 ;
6380 bool result;
6381 PyObject * obj0 = 0 ;
6382 PyObject * obj1 = 0 ;
6383 PyObject * obj2 = 0 ;
6384 char *kwnames[] = {
6385 (char *) "self",(char *) "x",(char *) "y", NULL
6386 };
6387
6388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6390 if (SWIG_arg_fail(1)) SWIG_fail;
6391 {
6392 arg2 = (int)(SWIG_As_int(obj1));
6393 if (SWIG_arg_fail(2)) SWIG_fail;
6394 }
6395 {
6396 arg3 = (int)(SWIG_As_int(obj2));
6397 if (SWIG_arg_fail(3)) SWIG_fail;
6398 }
6399 {
6400 PyThreadState* __tstate = wxPyBeginAllowThreads();
6401 result = (bool)(arg1)->Offset(arg2,arg3);
6402
6403 wxPyEndAllowThreads(__tstate);
6404 if (PyErr_Occurred()) SWIG_fail;
6405 }
6406 {
6407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6408 }
6409 return resultobj;
6410 fail:
6411 return NULL;
6412 }
6413
6414
6415 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6416 PyObject *resultobj;
6417 wxRegion *arg1 = (wxRegion *) 0 ;
6418 int arg2 ;
6419 int arg3 ;
6420 wxRegionContain result;
6421 PyObject * obj0 = 0 ;
6422 PyObject * obj1 = 0 ;
6423 PyObject * obj2 = 0 ;
6424 char *kwnames[] = {
6425 (char *) "self",(char *) "x",(char *) "y", NULL
6426 };
6427
6428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6430 if (SWIG_arg_fail(1)) SWIG_fail;
6431 {
6432 arg2 = (int)(SWIG_As_int(obj1));
6433 if (SWIG_arg_fail(2)) SWIG_fail;
6434 }
6435 {
6436 arg3 = (int)(SWIG_As_int(obj2));
6437 if (SWIG_arg_fail(3)) SWIG_fail;
6438 }
6439 {
6440 PyThreadState* __tstate = wxPyBeginAllowThreads();
6441 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6442
6443 wxPyEndAllowThreads(__tstate);
6444 if (PyErr_Occurred()) SWIG_fail;
6445 }
6446 resultobj = SWIG_From_int((result));
6447 return resultobj;
6448 fail:
6449 return NULL;
6450 }
6451
6452
6453 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6454 PyObject *resultobj;
6455 wxRegion *arg1 = (wxRegion *) 0 ;
6456 wxPoint *arg2 = 0 ;
6457 wxRegionContain result;
6458 wxPoint temp2 ;
6459 PyObject * obj0 = 0 ;
6460 PyObject * obj1 = 0 ;
6461 char *kwnames[] = {
6462 (char *) "self",(char *) "pt", NULL
6463 };
6464
6465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6467 if (SWIG_arg_fail(1)) SWIG_fail;
6468 {
6469 arg2 = &temp2;
6470 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6471 }
6472 {
6473 PyThreadState* __tstate = wxPyBeginAllowThreads();
6474 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
6475
6476 wxPyEndAllowThreads(__tstate);
6477 if (PyErr_Occurred()) SWIG_fail;
6478 }
6479 resultobj = SWIG_From_int((result));
6480 return resultobj;
6481 fail:
6482 return NULL;
6483 }
6484
6485
6486 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
6487 PyObject *resultobj;
6488 wxRegion *arg1 = (wxRegion *) 0 ;
6489 wxRect *arg2 = 0 ;
6490 wxRegionContain result;
6491 wxRect temp2 ;
6492 PyObject * obj0 = 0 ;
6493 PyObject * obj1 = 0 ;
6494 char *kwnames[] = {
6495 (char *) "self",(char *) "rect", NULL
6496 };
6497
6498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
6499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6500 if (SWIG_arg_fail(1)) SWIG_fail;
6501 {
6502 arg2 = &temp2;
6503 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6504 }
6505 {
6506 PyThreadState* __tstate = wxPyBeginAllowThreads();
6507 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
6508
6509 wxPyEndAllowThreads(__tstate);
6510 if (PyErr_Occurred()) SWIG_fail;
6511 }
6512 resultobj = SWIG_From_int((result));
6513 return resultobj;
6514 fail:
6515 return NULL;
6516 }
6517
6518
6519 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
6520 PyObject *resultobj;
6521 wxRegion *arg1 = (wxRegion *) 0 ;
6522 int arg2 ;
6523 int arg3 ;
6524 int arg4 ;
6525 int arg5 ;
6526 wxRegionContain result;
6527 PyObject * obj0 = 0 ;
6528 PyObject * obj1 = 0 ;
6529 PyObject * obj2 = 0 ;
6530 PyObject * obj3 = 0 ;
6531 PyObject * obj4 = 0 ;
6532 char *kwnames[] = {
6533 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
6534 };
6535
6536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6538 if (SWIG_arg_fail(1)) SWIG_fail;
6539 {
6540 arg2 = (int)(SWIG_As_int(obj1));
6541 if (SWIG_arg_fail(2)) SWIG_fail;
6542 }
6543 {
6544 arg3 = (int)(SWIG_As_int(obj2));
6545 if (SWIG_arg_fail(3)) SWIG_fail;
6546 }
6547 {
6548 arg4 = (int)(SWIG_As_int(obj3));
6549 if (SWIG_arg_fail(4)) SWIG_fail;
6550 }
6551 {
6552 arg5 = (int)(SWIG_As_int(obj4));
6553 if (SWIG_arg_fail(5)) SWIG_fail;
6554 }
6555 {
6556 PyThreadState* __tstate = wxPyBeginAllowThreads();
6557 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
6558
6559 wxPyEndAllowThreads(__tstate);
6560 if (PyErr_Occurred()) SWIG_fail;
6561 }
6562 resultobj = SWIG_From_int((result));
6563 return resultobj;
6564 fail:
6565 return NULL;
6566 }
6567
6568
6569 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
6570 PyObject *resultobj;
6571 wxRegion *arg1 = (wxRegion *) 0 ;
6572 wxRect result;
6573 PyObject * obj0 = 0 ;
6574 char *kwnames[] = {
6575 (char *) "self", NULL
6576 };
6577
6578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
6579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6580 if (SWIG_arg_fail(1)) SWIG_fail;
6581 {
6582 PyThreadState* __tstate = wxPyBeginAllowThreads();
6583 result = (arg1)->GetBox();
6584
6585 wxPyEndAllowThreads(__tstate);
6586 if (PyErr_Occurred()) SWIG_fail;
6587 }
6588 {
6589 wxRect * resultptr;
6590 resultptr = new wxRect((wxRect &)(result));
6591 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6592 }
6593 return resultobj;
6594 fail:
6595 return NULL;
6596 }
6597
6598
6599 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
6600 PyObject *resultobj;
6601 wxRegion *arg1 = (wxRegion *) 0 ;
6602 int arg2 ;
6603 int arg3 ;
6604 int arg4 ;
6605 int arg5 ;
6606 bool result;
6607 PyObject * obj0 = 0 ;
6608 PyObject * obj1 = 0 ;
6609 PyObject * obj2 = 0 ;
6610 PyObject * obj3 = 0 ;
6611 PyObject * obj4 = 0 ;
6612 char *kwnames[] = {
6613 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6614 };
6615
6616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6618 if (SWIG_arg_fail(1)) SWIG_fail;
6619 {
6620 arg2 = (int)(SWIG_As_int(obj1));
6621 if (SWIG_arg_fail(2)) SWIG_fail;
6622 }
6623 {
6624 arg3 = (int)(SWIG_As_int(obj2));
6625 if (SWIG_arg_fail(3)) SWIG_fail;
6626 }
6627 {
6628 arg4 = (int)(SWIG_As_int(obj3));
6629 if (SWIG_arg_fail(4)) SWIG_fail;
6630 }
6631 {
6632 arg5 = (int)(SWIG_As_int(obj4));
6633 if (SWIG_arg_fail(5)) SWIG_fail;
6634 }
6635 {
6636 PyThreadState* __tstate = wxPyBeginAllowThreads();
6637 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
6638
6639 wxPyEndAllowThreads(__tstate);
6640 if (PyErr_Occurred()) SWIG_fail;
6641 }
6642 {
6643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6644 }
6645 return resultobj;
6646 fail:
6647 return NULL;
6648 }
6649
6650
6651 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6652 PyObject *resultobj;
6653 wxRegion *arg1 = (wxRegion *) 0 ;
6654 wxRect *arg2 = 0 ;
6655 bool result;
6656 wxRect temp2 ;
6657 PyObject * obj0 = 0 ;
6658 PyObject * obj1 = 0 ;
6659 char *kwnames[] = {
6660 (char *) "self",(char *) "rect", NULL
6661 };
6662
6663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6665 if (SWIG_arg_fail(1)) SWIG_fail;
6666 {
6667 arg2 = &temp2;
6668 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6669 }
6670 {
6671 PyThreadState* __tstate = wxPyBeginAllowThreads();
6672 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
6673
6674 wxPyEndAllowThreads(__tstate);
6675 if (PyErr_Occurred()) SWIG_fail;
6676 }
6677 {
6678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6679 }
6680 return resultobj;
6681 fail:
6682 return NULL;
6683 }
6684
6685
6686 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6687 PyObject *resultobj;
6688 wxRegion *arg1 = (wxRegion *) 0 ;
6689 wxRegion *arg2 = 0 ;
6690 bool result;
6691 PyObject * obj0 = 0 ;
6692 PyObject * obj1 = 0 ;
6693 char *kwnames[] = {
6694 (char *) "self",(char *) "region", NULL
6695 };
6696
6697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
6698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6699 if (SWIG_arg_fail(1)) SWIG_fail;
6700 {
6701 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6702 if (SWIG_arg_fail(2)) SWIG_fail;
6703 if (arg2 == NULL) {
6704 SWIG_null_ref("wxRegion");
6705 }
6706 if (SWIG_arg_fail(2)) SWIG_fail;
6707 }
6708 {
6709 PyThreadState* __tstate = wxPyBeginAllowThreads();
6710 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
6711
6712 wxPyEndAllowThreads(__tstate);
6713 if (PyErr_Occurred()) SWIG_fail;
6714 }
6715 {
6716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6717 }
6718 return resultobj;
6719 fail:
6720 return NULL;
6721 }
6722
6723
6724 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
6725 PyObject *resultobj;
6726 wxRegion *arg1 = (wxRegion *) 0 ;
6727 bool result;
6728 PyObject * obj0 = 0 ;
6729 char *kwnames[] = {
6730 (char *) "self", NULL
6731 };
6732
6733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
6734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6735 if (SWIG_arg_fail(1)) SWIG_fail;
6736 {
6737 PyThreadState* __tstate = wxPyBeginAllowThreads();
6738 result = (bool)(arg1)->IsEmpty();
6739
6740 wxPyEndAllowThreads(__tstate);
6741 if (PyErr_Occurred()) SWIG_fail;
6742 }
6743 {
6744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6745 }
6746 return resultobj;
6747 fail:
6748 return NULL;
6749 }
6750
6751
6752 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6753 PyObject *resultobj;
6754 wxRegion *arg1 = (wxRegion *) 0 ;
6755 int arg2 ;
6756 int arg3 ;
6757 int arg4 ;
6758 int arg5 ;
6759 bool result;
6760 PyObject * obj0 = 0 ;
6761 PyObject * obj1 = 0 ;
6762 PyObject * obj2 = 0 ;
6763 PyObject * obj3 = 0 ;
6764 PyObject * obj4 = 0 ;
6765 char *kwnames[] = {
6766 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6767 };
6768
6769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6771 if (SWIG_arg_fail(1)) SWIG_fail;
6772 {
6773 arg2 = (int)(SWIG_As_int(obj1));
6774 if (SWIG_arg_fail(2)) SWIG_fail;
6775 }
6776 {
6777 arg3 = (int)(SWIG_As_int(obj2));
6778 if (SWIG_arg_fail(3)) SWIG_fail;
6779 }
6780 {
6781 arg4 = (int)(SWIG_As_int(obj3));
6782 if (SWIG_arg_fail(4)) SWIG_fail;
6783 }
6784 {
6785 arg5 = (int)(SWIG_As_int(obj4));
6786 if (SWIG_arg_fail(5)) SWIG_fail;
6787 }
6788 {
6789 PyThreadState* __tstate = wxPyBeginAllowThreads();
6790 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
6791
6792 wxPyEndAllowThreads(__tstate);
6793 if (PyErr_Occurred()) SWIG_fail;
6794 }
6795 {
6796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6797 }
6798 return resultobj;
6799 fail:
6800 return NULL;
6801 }
6802
6803
6804 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
6805 PyObject *resultobj;
6806 wxRegion *arg1 = (wxRegion *) 0 ;
6807 wxRect *arg2 = 0 ;
6808 bool result;
6809 wxRect temp2 ;
6810 PyObject * obj0 = 0 ;
6811 PyObject * obj1 = 0 ;
6812 char *kwnames[] = {
6813 (char *) "self",(char *) "rect", NULL
6814 };
6815
6816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
6817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6818 if (SWIG_arg_fail(1)) SWIG_fail;
6819 {
6820 arg2 = &temp2;
6821 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6822 }
6823 {
6824 PyThreadState* __tstate = wxPyBeginAllowThreads();
6825 result = (bool)(arg1)->Union((wxRect const &)*arg2);
6826
6827 wxPyEndAllowThreads(__tstate);
6828 if (PyErr_Occurred()) SWIG_fail;
6829 }
6830 {
6831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6832 }
6833 return resultobj;
6834 fail:
6835 return NULL;
6836 }
6837
6838
6839 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6840 PyObject *resultobj;
6841 wxRegion *arg1 = (wxRegion *) 0 ;
6842 wxRegion *arg2 = 0 ;
6843 bool result;
6844 PyObject * obj0 = 0 ;
6845 PyObject * obj1 = 0 ;
6846 char *kwnames[] = {
6847 (char *) "self",(char *) "region", NULL
6848 };
6849
6850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
6851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6852 if (SWIG_arg_fail(1)) SWIG_fail;
6853 {
6854 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6855 if (SWIG_arg_fail(2)) SWIG_fail;
6856 if (arg2 == NULL) {
6857 SWIG_null_ref("wxRegion");
6858 }
6859 if (SWIG_arg_fail(2)) SWIG_fail;
6860 }
6861 {
6862 PyThreadState* __tstate = wxPyBeginAllowThreads();
6863 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
6864
6865 wxPyEndAllowThreads(__tstate);
6866 if (PyErr_Occurred()) SWIG_fail;
6867 }
6868 {
6869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6870 }
6871 return resultobj;
6872 fail:
6873 return NULL;
6874 }
6875
6876
6877 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
6878 PyObject *resultobj;
6879 wxRegion *arg1 = (wxRegion *) 0 ;
6880 int arg2 ;
6881 int arg3 ;
6882 int arg4 ;
6883 int arg5 ;
6884 bool result;
6885 PyObject * obj0 = 0 ;
6886 PyObject * obj1 = 0 ;
6887 PyObject * obj2 = 0 ;
6888 PyObject * obj3 = 0 ;
6889 PyObject * obj4 = 0 ;
6890 char *kwnames[] = {
6891 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6892 };
6893
6894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6896 if (SWIG_arg_fail(1)) SWIG_fail;
6897 {
6898 arg2 = (int)(SWIG_As_int(obj1));
6899 if (SWIG_arg_fail(2)) SWIG_fail;
6900 }
6901 {
6902 arg3 = (int)(SWIG_As_int(obj2));
6903 if (SWIG_arg_fail(3)) SWIG_fail;
6904 }
6905 {
6906 arg4 = (int)(SWIG_As_int(obj3));
6907 if (SWIG_arg_fail(4)) SWIG_fail;
6908 }
6909 {
6910 arg5 = (int)(SWIG_As_int(obj4));
6911 if (SWIG_arg_fail(5)) SWIG_fail;
6912 }
6913 {
6914 PyThreadState* __tstate = wxPyBeginAllowThreads();
6915 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
6916
6917 wxPyEndAllowThreads(__tstate);
6918 if (PyErr_Occurred()) SWIG_fail;
6919 }
6920 {
6921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6922 }
6923 return resultobj;
6924 fail:
6925 return NULL;
6926 }
6927
6928
6929 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
6930 PyObject *resultobj;
6931 wxRegion *arg1 = (wxRegion *) 0 ;
6932 wxRect *arg2 = 0 ;
6933 bool result;
6934 wxRect temp2 ;
6935 PyObject * obj0 = 0 ;
6936 PyObject * obj1 = 0 ;
6937 char *kwnames[] = {
6938 (char *) "self",(char *) "rect", NULL
6939 };
6940
6941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
6942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6943 if (SWIG_arg_fail(1)) SWIG_fail;
6944 {
6945 arg2 = &temp2;
6946 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6947 }
6948 {
6949 PyThreadState* __tstate = wxPyBeginAllowThreads();
6950 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
6951
6952 wxPyEndAllowThreads(__tstate);
6953 if (PyErr_Occurred()) SWIG_fail;
6954 }
6955 {
6956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6957 }
6958 return resultobj;
6959 fail:
6960 return NULL;
6961 }
6962
6963
6964 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6965 PyObject *resultobj;
6966 wxRegion *arg1 = (wxRegion *) 0 ;
6967 wxRegion *arg2 = 0 ;
6968 bool result;
6969 PyObject * obj0 = 0 ;
6970 PyObject * obj1 = 0 ;
6971 char *kwnames[] = {
6972 (char *) "self",(char *) "region", NULL
6973 };
6974
6975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
6976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6977 if (SWIG_arg_fail(1)) SWIG_fail;
6978 {
6979 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6980 if (SWIG_arg_fail(2)) SWIG_fail;
6981 if (arg2 == NULL) {
6982 SWIG_null_ref("wxRegion");
6983 }
6984 if (SWIG_arg_fail(2)) SWIG_fail;
6985 }
6986 {
6987 PyThreadState* __tstate = wxPyBeginAllowThreads();
6988 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
6989
6990 wxPyEndAllowThreads(__tstate);
6991 if (PyErr_Occurred()) SWIG_fail;
6992 }
6993 {
6994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6995 }
6996 return resultobj;
6997 fail:
6998 return NULL;
6999 }
7000
7001
7002 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
7003 PyObject *resultobj;
7004 wxRegion *arg1 = (wxRegion *) 0 ;
7005 int arg2 ;
7006 int arg3 ;
7007 int arg4 ;
7008 int arg5 ;
7009 bool result;
7010 PyObject * obj0 = 0 ;
7011 PyObject * obj1 = 0 ;
7012 PyObject * obj2 = 0 ;
7013 PyObject * obj3 = 0 ;
7014 PyObject * obj4 = 0 ;
7015 char *kwnames[] = {
7016 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7017 };
7018
7019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7021 if (SWIG_arg_fail(1)) SWIG_fail;
7022 {
7023 arg2 = (int)(SWIG_As_int(obj1));
7024 if (SWIG_arg_fail(2)) SWIG_fail;
7025 }
7026 {
7027 arg3 = (int)(SWIG_As_int(obj2));
7028 if (SWIG_arg_fail(3)) SWIG_fail;
7029 }
7030 {
7031 arg4 = (int)(SWIG_As_int(obj3));
7032 if (SWIG_arg_fail(4)) SWIG_fail;
7033 }
7034 {
7035 arg5 = (int)(SWIG_As_int(obj4));
7036 if (SWIG_arg_fail(5)) SWIG_fail;
7037 }
7038 {
7039 PyThreadState* __tstate = wxPyBeginAllowThreads();
7040 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
7041
7042 wxPyEndAllowThreads(__tstate);
7043 if (PyErr_Occurred()) SWIG_fail;
7044 }
7045 {
7046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7047 }
7048 return resultobj;
7049 fail:
7050 return NULL;
7051 }
7052
7053
7054 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
7055 PyObject *resultobj;
7056 wxRegion *arg1 = (wxRegion *) 0 ;
7057 wxRect *arg2 = 0 ;
7058 bool result;
7059 wxRect temp2 ;
7060 PyObject * obj0 = 0 ;
7061 PyObject * obj1 = 0 ;
7062 char *kwnames[] = {
7063 (char *) "self",(char *) "rect", NULL
7064 };
7065
7066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7068 if (SWIG_arg_fail(1)) SWIG_fail;
7069 {
7070 arg2 = &temp2;
7071 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7072 }
7073 {
7074 PyThreadState* __tstate = wxPyBeginAllowThreads();
7075 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7076
7077 wxPyEndAllowThreads(__tstate);
7078 if (PyErr_Occurred()) SWIG_fail;
7079 }
7080 {
7081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7082 }
7083 return resultobj;
7084 fail:
7085 return NULL;
7086 }
7087
7088
7089 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7090 PyObject *resultobj;
7091 wxRegion *arg1 = (wxRegion *) 0 ;
7092 wxRegion *arg2 = 0 ;
7093 bool result;
7094 PyObject * obj0 = 0 ;
7095 PyObject * obj1 = 0 ;
7096 char *kwnames[] = {
7097 (char *) "self",(char *) "region", NULL
7098 };
7099
7100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7102 if (SWIG_arg_fail(1)) SWIG_fail;
7103 {
7104 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7105 if (SWIG_arg_fail(2)) SWIG_fail;
7106 if (arg2 == NULL) {
7107 SWIG_null_ref("wxRegion");
7108 }
7109 if (SWIG_arg_fail(2)) SWIG_fail;
7110 }
7111 {
7112 PyThreadState* __tstate = wxPyBeginAllowThreads();
7113 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7114
7115 wxPyEndAllowThreads(__tstate);
7116 if (PyErr_Occurred()) SWIG_fail;
7117 }
7118 {
7119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7120 }
7121 return resultobj;
7122 fail:
7123 return NULL;
7124 }
7125
7126
7127 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7128 PyObject *resultobj;
7129 wxRegion *arg1 = (wxRegion *) 0 ;
7130 SwigValueWrapper<wxBitmap > result;
7131 PyObject * obj0 = 0 ;
7132 char *kwnames[] = {
7133 (char *) "self", NULL
7134 };
7135
7136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7138 if (SWIG_arg_fail(1)) SWIG_fail;
7139 {
7140 PyThreadState* __tstate = wxPyBeginAllowThreads();
7141 result = (arg1)->ConvertToBitmap();
7142
7143 wxPyEndAllowThreads(__tstate);
7144 if (PyErr_Occurred()) SWIG_fail;
7145 }
7146 {
7147 wxBitmap * resultptr;
7148 resultptr = new wxBitmap((wxBitmap &)(result));
7149 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7150 }
7151 return resultobj;
7152 fail:
7153 return NULL;
7154 }
7155
7156
7157 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7158 PyObject *resultobj;
7159 wxRegion *arg1 = (wxRegion *) 0 ;
7160 wxBitmap *arg2 = 0 ;
7161 bool result;
7162 PyObject * obj0 = 0 ;
7163 PyObject * obj1 = 0 ;
7164 char *kwnames[] = {
7165 (char *) "self",(char *) "bmp", NULL
7166 };
7167
7168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7170 if (SWIG_arg_fail(1)) SWIG_fail;
7171 {
7172 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7173 if (SWIG_arg_fail(2)) SWIG_fail;
7174 if (arg2 == NULL) {
7175 SWIG_null_ref("wxBitmap");
7176 }
7177 if (SWIG_arg_fail(2)) SWIG_fail;
7178 }
7179 {
7180 PyThreadState* __tstate = wxPyBeginAllowThreads();
7181 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7182
7183 wxPyEndAllowThreads(__tstate);
7184 if (PyErr_Occurred()) SWIG_fail;
7185 }
7186 {
7187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7188 }
7189 return resultobj;
7190 fail:
7191 return NULL;
7192 }
7193
7194
7195 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7196 PyObject *resultobj;
7197 wxRegion *arg1 = (wxRegion *) 0 ;
7198 wxBitmap *arg2 = 0 ;
7199 wxColour *arg3 = 0 ;
7200 int arg4 = (int) 0 ;
7201 bool result;
7202 wxColour temp3 ;
7203 PyObject * obj0 = 0 ;
7204 PyObject * obj1 = 0 ;
7205 PyObject * obj2 = 0 ;
7206 PyObject * obj3 = 0 ;
7207 char *kwnames[] = {
7208 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7209 };
7210
7211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7213 if (SWIG_arg_fail(1)) SWIG_fail;
7214 {
7215 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7216 if (SWIG_arg_fail(2)) SWIG_fail;
7217 if (arg2 == NULL) {
7218 SWIG_null_ref("wxBitmap");
7219 }
7220 if (SWIG_arg_fail(2)) SWIG_fail;
7221 }
7222 {
7223 arg3 = &temp3;
7224 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7225 }
7226 if (obj3) {
7227 {
7228 arg4 = (int)(SWIG_As_int(obj3));
7229 if (SWIG_arg_fail(4)) SWIG_fail;
7230 }
7231 }
7232 {
7233 PyThreadState* __tstate = wxPyBeginAllowThreads();
7234 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7235
7236 wxPyEndAllowThreads(__tstate);
7237 if (PyErr_Occurred()) SWIG_fail;
7238 }
7239 {
7240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7241 }
7242 return resultobj;
7243 fail:
7244 return NULL;
7245 }
7246
7247
7248 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7249 PyObject *obj;
7250 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7251 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7252 Py_INCREF(obj);
7253 return Py_BuildValue((char *)"");
7254 }
7255 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7256 PyObject *resultobj;
7257 wxRegion *arg1 = 0 ;
7258 wxRegionIterator *result;
7259 PyObject * obj0 = 0 ;
7260 char *kwnames[] = {
7261 (char *) "region", NULL
7262 };
7263
7264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7265 {
7266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7267 if (SWIG_arg_fail(1)) SWIG_fail;
7268 if (arg1 == NULL) {
7269 SWIG_null_ref("wxRegion");
7270 }
7271 if (SWIG_arg_fail(1)) SWIG_fail;
7272 }
7273 {
7274 if (!wxPyCheckForApp()) SWIG_fail;
7275 PyThreadState* __tstate = wxPyBeginAllowThreads();
7276 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7277
7278 wxPyEndAllowThreads(__tstate);
7279 if (PyErr_Occurred()) SWIG_fail;
7280 }
7281 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7282 return resultobj;
7283 fail:
7284 return NULL;
7285 }
7286
7287
7288 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7289 PyObject *resultobj;
7290 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7291 PyObject * obj0 = 0 ;
7292 char *kwnames[] = {
7293 (char *) "self", NULL
7294 };
7295
7296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7298 if (SWIG_arg_fail(1)) SWIG_fail;
7299 {
7300 PyThreadState* __tstate = wxPyBeginAllowThreads();
7301 delete arg1;
7302
7303 wxPyEndAllowThreads(__tstate);
7304 if (PyErr_Occurred()) SWIG_fail;
7305 }
7306 Py_INCREF(Py_None); resultobj = Py_None;
7307 return resultobj;
7308 fail:
7309 return NULL;
7310 }
7311
7312
7313 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7314 PyObject *resultobj;
7315 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7316 int result;
7317 PyObject * obj0 = 0 ;
7318 char *kwnames[] = {
7319 (char *) "self", NULL
7320 };
7321
7322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7324 if (SWIG_arg_fail(1)) SWIG_fail;
7325 {
7326 PyThreadState* __tstate = wxPyBeginAllowThreads();
7327 result = (int)(arg1)->GetX();
7328
7329 wxPyEndAllowThreads(__tstate);
7330 if (PyErr_Occurred()) SWIG_fail;
7331 }
7332 {
7333 resultobj = SWIG_From_int((int)(result));
7334 }
7335 return resultobj;
7336 fail:
7337 return NULL;
7338 }
7339
7340
7341 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7342 PyObject *resultobj;
7343 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7344 int result;
7345 PyObject * obj0 = 0 ;
7346 char *kwnames[] = {
7347 (char *) "self", NULL
7348 };
7349
7350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7352 if (SWIG_arg_fail(1)) SWIG_fail;
7353 {
7354 PyThreadState* __tstate = wxPyBeginAllowThreads();
7355 result = (int)(arg1)->GetY();
7356
7357 wxPyEndAllowThreads(__tstate);
7358 if (PyErr_Occurred()) SWIG_fail;
7359 }
7360 {
7361 resultobj = SWIG_From_int((int)(result));
7362 }
7363 return resultobj;
7364 fail:
7365 return NULL;
7366 }
7367
7368
7369 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7370 PyObject *resultobj;
7371 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7372 int result;
7373 PyObject * obj0 = 0 ;
7374 char *kwnames[] = {
7375 (char *) "self", NULL
7376 };
7377
7378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7380 if (SWIG_arg_fail(1)) SWIG_fail;
7381 {
7382 PyThreadState* __tstate = wxPyBeginAllowThreads();
7383 result = (int)(arg1)->GetW();
7384
7385 wxPyEndAllowThreads(__tstate);
7386 if (PyErr_Occurred()) SWIG_fail;
7387 }
7388 {
7389 resultobj = SWIG_From_int((int)(result));
7390 }
7391 return resultobj;
7392 fail:
7393 return NULL;
7394 }
7395
7396
7397 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7398 PyObject *resultobj;
7399 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7400 int result;
7401 PyObject * obj0 = 0 ;
7402 char *kwnames[] = {
7403 (char *) "self", NULL
7404 };
7405
7406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7408 if (SWIG_arg_fail(1)) SWIG_fail;
7409 {
7410 PyThreadState* __tstate = wxPyBeginAllowThreads();
7411 result = (int)(arg1)->GetWidth();
7412
7413 wxPyEndAllowThreads(__tstate);
7414 if (PyErr_Occurred()) SWIG_fail;
7415 }
7416 {
7417 resultobj = SWIG_From_int((int)(result));
7418 }
7419 return resultobj;
7420 fail:
7421 return NULL;
7422 }
7423
7424
7425 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7426 PyObject *resultobj;
7427 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7428 int result;
7429 PyObject * obj0 = 0 ;
7430 char *kwnames[] = {
7431 (char *) "self", NULL
7432 };
7433
7434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7436 if (SWIG_arg_fail(1)) SWIG_fail;
7437 {
7438 PyThreadState* __tstate = wxPyBeginAllowThreads();
7439 result = (int)(arg1)->GetH();
7440
7441 wxPyEndAllowThreads(__tstate);
7442 if (PyErr_Occurred()) SWIG_fail;
7443 }
7444 {
7445 resultobj = SWIG_From_int((int)(result));
7446 }
7447 return resultobj;
7448 fail:
7449 return NULL;
7450 }
7451
7452
7453 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7454 PyObject *resultobj;
7455 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7456 int result;
7457 PyObject * obj0 = 0 ;
7458 char *kwnames[] = {
7459 (char *) "self", NULL
7460 };
7461
7462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7464 if (SWIG_arg_fail(1)) SWIG_fail;
7465 {
7466 PyThreadState* __tstate = wxPyBeginAllowThreads();
7467 result = (int)(arg1)->GetHeight();
7468
7469 wxPyEndAllowThreads(__tstate);
7470 if (PyErr_Occurred()) SWIG_fail;
7471 }
7472 {
7473 resultobj = SWIG_From_int((int)(result));
7474 }
7475 return resultobj;
7476 fail:
7477 return NULL;
7478 }
7479
7480
7481 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
7482 PyObject *resultobj;
7483 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7484 wxRect result;
7485 PyObject * obj0 = 0 ;
7486 char *kwnames[] = {
7487 (char *) "self", NULL
7488 };
7489
7490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
7491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7492 if (SWIG_arg_fail(1)) SWIG_fail;
7493 {
7494 PyThreadState* __tstate = wxPyBeginAllowThreads();
7495 result = (arg1)->GetRect();
7496
7497 wxPyEndAllowThreads(__tstate);
7498 if (PyErr_Occurred()) SWIG_fail;
7499 }
7500 {
7501 wxRect * resultptr;
7502 resultptr = new wxRect((wxRect &)(result));
7503 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7504 }
7505 return resultobj;
7506 fail:
7507 return NULL;
7508 }
7509
7510
7511 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
7512 PyObject *resultobj;
7513 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7514 bool result;
7515 PyObject * obj0 = 0 ;
7516 char *kwnames[] = {
7517 (char *) "self", NULL
7518 };
7519
7520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
7521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7522 if (SWIG_arg_fail(1)) SWIG_fail;
7523 {
7524 PyThreadState* __tstate = wxPyBeginAllowThreads();
7525 result = (bool)(arg1)->HaveRects();
7526
7527 wxPyEndAllowThreads(__tstate);
7528 if (PyErr_Occurred()) SWIG_fail;
7529 }
7530 {
7531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7532 }
7533 return resultobj;
7534 fail:
7535 return NULL;
7536 }
7537
7538
7539 static PyObject *_wrap_RegionIterator_Reset(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_Reset",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 (arg1)->Reset();
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_Next(PyObject *, PyObject *args, PyObject *kwargs) {
7565 PyObject *resultobj;
7566 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7567 PyObject * obj0 = 0 ;
7568 char *kwnames[] = {
7569 (char *) "self", NULL
7570 };
7571
7572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
7573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7574 if (SWIG_arg_fail(1)) SWIG_fail;
7575 {
7576 PyThreadState* __tstate = wxPyBeginAllowThreads();
7577 wxRegionIterator_Next(arg1);
7578
7579 wxPyEndAllowThreads(__tstate);
7580 if (PyErr_Occurred()) SWIG_fail;
7581 }
7582 Py_INCREF(Py_None); resultobj = Py_None;
7583 return resultobj;
7584 fail:
7585 return NULL;
7586 }
7587
7588
7589 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
7590 PyObject *resultobj;
7591 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7592 bool result;
7593 PyObject * obj0 = 0 ;
7594 char *kwnames[] = {
7595 (char *) "self", NULL
7596 };
7597
7598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
7599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7600 if (SWIG_arg_fail(1)) SWIG_fail;
7601 {
7602 PyThreadState* __tstate = wxPyBeginAllowThreads();
7603 result = (bool)wxRegionIterator___nonzero__(arg1);
7604
7605 wxPyEndAllowThreads(__tstate);
7606 if (PyErr_Occurred()) SWIG_fail;
7607 }
7608 {
7609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7610 }
7611 return resultobj;
7612 fail:
7613 return NULL;
7614 }
7615
7616
7617 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
7618 PyObject *obj;
7619 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7620 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
7621 Py_INCREF(obj);
7622 return Py_BuildValue((char *)"");
7623 }
7624 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7625 PyObject *resultobj;
7626 wxNativeFontInfo *result;
7627 char *kwnames[] = {
7628 NULL
7629 };
7630
7631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
7632 {
7633 PyThreadState* __tstate = wxPyBeginAllowThreads();
7634 result = (wxNativeFontInfo *)new wxNativeFontInfo();
7635
7636 wxPyEndAllowThreads(__tstate);
7637 if (PyErr_Occurred()) SWIG_fail;
7638 }
7639 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
7640 return resultobj;
7641 fail:
7642 return NULL;
7643 }
7644
7645
7646 static PyObject *_wrap_delete_NativeFontInfo(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:delete_NativeFontInfo",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 delete arg1;
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_Init(PyObject *, PyObject *args, PyObject *kwargs) {
7672 PyObject *resultobj;
7673 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7674 PyObject * obj0 = 0 ;
7675 char *kwnames[] = {
7676 (char *) "self", NULL
7677 };
7678
7679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
7680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7681 if (SWIG_arg_fail(1)) SWIG_fail;
7682 {
7683 PyThreadState* __tstate = wxPyBeginAllowThreads();
7684 (arg1)->Init();
7685
7686 wxPyEndAllowThreads(__tstate);
7687 if (PyErr_Occurred()) SWIG_fail;
7688 }
7689 Py_INCREF(Py_None); resultobj = Py_None;
7690 return resultobj;
7691 fail:
7692 return NULL;
7693 }
7694
7695
7696 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
7697 PyObject *resultobj;
7698 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7699 wxFont *arg2 = 0 ;
7700 PyObject * obj0 = 0 ;
7701 PyObject * obj1 = 0 ;
7702 char *kwnames[] = {
7703 (char *) "self",(char *) "font", NULL
7704 };
7705
7706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
7707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7708 if (SWIG_arg_fail(1)) SWIG_fail;
7709 {
7710 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
7711 if (SWIG_arg_fail(2)) SWIG_fail;
7712 if (arg2 == NULL) {
7713 SWIG_null_ref("wxFont");
7714 }
7715 if (SWIG_arg_fail(2)) SWIG_fail;
7716 }
7717 {
7718 PyThreadState* __tstate = wxPyBeginAllowThreads();
7719 (arg1)->InitFromFont((wxFont const &)*arg2);
7720
7721 wxPyEndAllowThreads(__tstate);
7722 if (PyErr_Occurred()) SWIG_fail;
7723 }
7724 Py_INCREF(Py_None); resultobj = Py_None;
7725 return resultobj;
7726 fail:
7727 return NULL;
7728 }
7729
7730
7731 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7732 PyObject *resultobj;
7733 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7734 int result;
7735 PyObject * obj0 = 0 ;
7736 char *kwnames[] = {
7737 (char *) "self", NULL
7738 };
7739
7740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
7741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7742 if (SWIG_arg_fail(1)) SWIG_fail;
7743 {
7744 PyThreadState* __tstate = wxPyBeginAllowThreads();
7745 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
7746
7747 wxPyEndAllowThreads(__tstate);
7748 if (PyErr_Occurred()) SWIG_fail;
7749 }
7750 {
7751 resultobj = SWIG_From_int((int)(result));
7752 }
7753 return resultobj;
7754 fail:
7755 return NULL;
7756 }
7757
7758
7759 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7760 PyObject *resultobj;
7761 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7762 wxFontStyle result;
7763 PyObject * obj0 = 0 ;
7764 char *kwnames[] = {
7765 (char *) "self", NULL
7766 };
7767
7768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
7769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7770 if (SWIG_arg_fail(1)) SWIG_fail;
7771 {
7772 PyThreadState* __tstate = wxPyBeginAllowThreads();
7773 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
7774
7775 wxPyEndAllowThreads(__tstate);
7776 if (PyErr_Occurred()) SWIG_fail;
7777 }
7778 resultobj = SWIG_From_int((result));
7779 return resultobj;
7780 fail:
7781 return NULL;
7782 }
7783
7784
7785 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7786 PyObject *resultobj;
7787 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7788 wxFontWeight result;
7789 PyObject * obj0 = 0 ;
7790 char *kwnames[] = {
7791 (char *) "self", NULL
7792 };
7793
7794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
7795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7796 if (SWIG_arg_fail(1)) SWIG_fail;
7797 {
7798 PyThreadState* __tstate = wxPyBeginAllowThreads();
7799 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
7800
7801 wxPyEndAllowThreads(__tstate);
7802 if (PyErr_Occurred()) SWIG_fail;
7803 }
7804 resultobj = SWIG_From_int((result));
7805 return resultobj;
7806 fail:
7807 return NULL;
7808 }
7809
7810
7811 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7812 PyObject *resultobj;
7813 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7814 bool result;
7815 PyObject * obj0 = 0 ;
7816 char *kwnames[] = {
7817 (char *) "self", NULL
7818 };
7819
7820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
7821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7822 if (SWIG_arg_fail(1)) SWIG_fail;
7823 {
7824 PyThreadState* __tstate = wxPyBeginAllowThreads();
7825 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
7826
7827 wxPyEndAllowThreads(__tstate);
7828 if (PyErr_Occurred()) SWIG_fail;
7829 }
7830 {
7831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7832 }
7833 return resultobj;
7834 fail:
7835 return NULL;
7836 }
7837
7838
7839 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7840 PyObject *resultobj;
7841 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7842 wxString result;
7843 PyObject * obj0 = 0 ;
7844 char *kwnames[] = {
7845 (char *) "self", NULL
7846 };
7847
7848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
7849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7850 if (SWIG_arg_fail(1)) SWIG_fail;
7851 {
7852 PyThreadState* __tstate = wxPyBeginAllowThreads();
7853 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
7854
7855 wxPyEndAllowThreads(__tstate);
7856 if (PyErr_Occurred()) SWIG_fail;
7857 }
7858 {
7859 #if wxUSE_UNICODE
7860 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7861 #else
7862 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7863 #endif
7864 }
7865 return resultobj;
7866 fail:
7867 return NULL;
7868 }
7869
7870
7871 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
7872 PyObject *resultobj;
7873 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7874 wxFontFamily result;
7875 PyObject * obj0 = 0 ;
7876 char *kwnames[] = {
7877 (char *) "self", NULL
7878 };
7879
7880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
7881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7882 if (SWIG_arg_fail(1)) SWIG_fail;
7883 {
7884 PyThreadState* __tstate = wxPyBeginAllowThreads();
7885 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
7886
7887 wxPyEndAllowThreads(__tstate);
7888 if (PyErr_Occurred()) SWIG_fail;
7889 }
7890 resultobj = SWIG_From_int((result));
7891 return resultobj;
7892 fail:
7893 return NULL;
7894 }
7895
7896
7897 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
7898 PyObject *resultobj;
7899 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7900 wxFontEncoding result;
7901 PyObject * obj0 = 0 ;
7902 char *kwnames[] = {
7903 (char *) "self", NULL
7904 };
7905
7906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
7907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7908 if (SWIG_arg_fail(1)) SWIG_fail;
7909 {
7910 PyThreadState* __tstate = wxPyBeginAllowThreads();
7911 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
7912
7913 wxPyEndAllowThreads(__tstate);
7914 if (PyErr_Occurred()) SWIG_fail;
7915 }
7916 resultobj = SWIG_From_int((result));
7917 return resultobj;
7918 fail:
7919 return NULL;
7920 }
7921
7922
7923 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7924 PyObject *resultobj;
7925 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7926 int arg2 ;
7927 PyObject * obj0 = 0 ;
7928 PyObject * obj1 = 0 ;
7929 char *kwnames[] = {
7930 (char *) "self",(char *) "pointsize", NULL
7931 };
7932
7933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
7934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7935 if (SWIG_arg_fail(1)) SWIG_fail;
7936 {
7937 arg2 = (int)(SWIG_As_int(obj1));
7938 if (SWIG_arg_fail(2)) SWIG_fail;
7939 }
7940 {
7941 PyThreadState* __tstate = wxPyBeginAllowThreads();
7942 (arg1)->SetPointSize(arg2);
7943
7944 wxPyEndAllowThreads(__tstate);
7945 if (PyErr_Occurred()) SWIG_fail;
7946 }
7947 Py_INCREF(Py_None); resultobj = Py_None;
7948 return resultobj;
7949 fail:
7950 return NULL;
7951 }
7952
7953
7954 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7955 PyObject *resultobj;
7956 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7957 wxFontStyle arg2 ;
7958 PyObject * obj0 = 0 ;
7959 PyObject * obj1 = 0 ;
7960 char *kwnames[] = {
7961 (char *) "self",(char *) "style", NULL
7962 };
7963
7964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
7965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7966 if (SWIG_arg_fail(1)) SWIG_fail;
7967 {
7968 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
7969 if (SWIG_arg_fail(2)) SWIG_fail;
7970 }
7971 {
7972 PyThreadState* __tstate = wxPyBeginAllowThreads();
7973 (arg1)->SetStyle((wxFontStyle )arg2);
7974
7975 wxPyEndAllowThreads(__tstate);
7976 if (PyErr_Occurred()) SWIG_fail;
7977 }
7978 Py_INCREF(Py_None); resultobj = Py_None;
7979 return resultobj;
7980 fail:
7981 return NULL;
7982 }
7983
7984
7985 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7986 PyObject *resultobj;
7987 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7988 wxFontWeight arg2 ;
7989 PyObject * obj0 = 0 ;
7990 PyObject * obj1 = 0 ;
7991 char *kwnames[] = {
7992 (char *) "self",(char *) "weight", NULL
7993 };
7994
7995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
7996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7997 if (SWIG_arg_fail(1)) SWIG_fail;
7998 {
7999 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
8000 if (SWIG_arg_fail(2)) SWIG_fail;
8001 }
8002 {
8003 PyThreadState* __tstate = wxPyBeginAllowThreads();
8004 (arg1)->SetWeight((wxFontWeight )arg2);
8005
8006 wxPyEndAllowThreads(__tstate);
8007 if (PyErr_Occurred()) SWIG_fail;
8008 }
8009 Py_INCREF(Py_None); resultobj = Py_None;
8010 return resultobj;
8011 fail:
8012 return NULL;
8013 }
8014
8015
8016 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8017 PyObject *resultobj;
8018 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8019 bool arg2 ;
8020 PyObject * obj0 = 0 ;
8021 PyObject * obj1 = 0 ;
8022 char *kwnames[] = {
8023 (char *) "self",(char *) "underlined", NULL
8024 };
8025
8026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
8027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8028 if (SWIG_arg_fail(1)) SWIG_fail;
8029 {
8030 arg2 = (bool)(SWIG_As_bool(obj1));
8031 if (SWIG_arg_fail(2)) SWIG_fail;
8032 }
8033 {
8034 PyThreadState* __tstate = wxPyBeginAllowThreads();
8035 (arg1)->SetUnderlined(arg2);
8036
8037 wxPyEndAllowThreads(__tstate);
8038 if (PyErr_Occurred()) SWIG_fail;
8039 }
8040 Py_INCREF(Py_None); resultobj = Py_None;
8041 return resultobj;
8042 fail:
8043 return NULL;
8044 }
8045
8046
8047 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8048 PyObject *resultobj;
8049 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8050 wxString arg2 ;
8051 PyObject * obj0 = 0 ;
8052 PyObject * obj1 = 0 ;
8053 char *kwnames[] = {
8054 (char *) "self",(char *) "facename", NULL
8055 };
8056
8057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
8058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8059 if (SWIG_arg_fail(1)) SWIG_fail;
8060 {
8061 wxString* sptr = wxString_in_helper(obj1);
8062 if (sptr == NULL) SWIG_fail;
8063 arg2 = *sptr;
8064 delete sptr;
8065 }
8066 {
8067 PyThreadState* __tstate = wxPyBeginAllowThreads();
8068 (arg1)->SetFaceName(arg2);
8069
8070 wxPyEndAllowThreads(__tstate);
8071 if (PyErr_Occurred()) SWIG_fail;
8072 }
8073 Py_INCREF(Py_None); resultobj = Py_None;
8074 return resultobj;
8075 fail:
8076 return NULL;
8077 }
8078
8079
8080 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8081 PyObject *resultobj;
8082 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8083 wxFontFamily arg2 ;
8084 PyObject * obj0 = 0 ;
8085 PyObject * obj1 = 0 ;
8086 char *kwnames[] = {
8087 (char *) "self",(char *) "family", NULL
8088 };
8089
8090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8092 if (SWIG_arg_fail(1)) SWIG_fail;
8093 {
8094 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8095 if (SWIG_arg_fail(2)) SWIG_fail;
8096 }
8097 {
8098 PyThreadState* __tstate = wxPyBeginAllowThreads();
8099 (arg1)->SetFamily((wxFontFamily )arg2);
8100
8101 wxPyEndAllowThreads(__tstate);
8102 if (PyErr_Occurred()) SWIG_fail;
8103 }
8104 Py_INCREF(Py_None); resultobj = Py_None;
8105 return resultobj;
8106 fail:
8107 return NULL;
8108 }
8109
8110
8111 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8112 PyObject *resultobj;
8113 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8114 wxFontEncoding arg2 ;
8115 PyObject * obj0 = 0 ;
8116 PyObject * obj1 = 0 ;
8117 char *kwnames[] = {
8118 (char *) "self",(char *) "encoding", NULL
8119 };
8120
8121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8123 if (SWIG_arg_fail(1)) SWIG_fail;
8124 {
8125 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8126 if (SWIG_arg_fail(2)) SWIG_fail;
8127 }
8128 {
8129 PyThreadState* __tstate = wxPyBeginAllowThreads();
8130 (arg1)->SetEncoding((wxFontEncoding )arg2);
8131
8132 wxPyEndAllowThreads(__tstate);
8133 if (PyErr_Occurred()) SWIG_fail;
8134 }
8135 Py_INCREF(Py_None); resultobj = Py_None;
8136 return resultobj;
8137 fail:
8138 return NULL;
8139 }
8140
8141
8142 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8143 PyObject *resultobj;
8144 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8145 wxString *arg2 = 0 ;
8146 bool result;
8147 bool temp2 = false ;
8148 PyObject * obj0 = 0 ;
8149 PyObject * obj1 = 0 ;
8150 char *kwnames[] = {
8151 (char *) "self",(char *) "s", NULL
8152 };
8153
8154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8156 if (SWIG_arg_fail(1)) SWIG_fail;
8157 {
8158 arg2 = wxString_in_helper(obj1);
8159 if (arg2 == NULL) SWIG_fail;
8160 temp2 = true;
8161 }
8162 {
8163 PyThreadState* __tstate = wxPyBeginAllowThreads();
8164 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8165
8166 wxPyEndAllowThreads(__tstate);
8167 if (PyErr_Occurred()) SWIG_fail;
8168 }
8169 {
8170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8171 }
8172 {
8173 if (temp2)
8174 delete arg2;
8175 }
8176 return resultobj;
8177 fail:
8178 {
8179 if (temp2)
8180 delete arg2;
8181 }
8182 return NULL;
8183 }
8184
8185
8186 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8187 PyObject *resultobj;
8188 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8189 wxString result;
8190 PyObject * obj0 = 0 ;
8191 char *kwnames[] = {
8192 (char *) "self", NULL
8193 };
8194
8195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8197 if (SWIG_arg_fail(1)) SWIG_fail;
8198 {
8199 PyThreadState* __tstate = wxPyBeginAllowThreads();
8200 result = ((wxNativeFontInfo const *)arg1)->ToString();
8201
8202 wxPyEndAllowThreads(__tstate);
8203 if (PyErr_Occurred()) SWIG_fail;
8204 }
8205 {
8206 #if wxUSE_UNICODE
8207 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8208 #else
8209 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8210 #endif
8211 }
8212 return resultobj;
8213 fail:
8214 return NULL;
8215 }
8216
8217
8218 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8219 PyObject *resultobj;
8220 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8221 wxString result;
8222 PyObject * obj0 = 0 ;
8223 char *kwnames[] = {
8224 (char *) "self", NULL
8225 };
8226
8227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8229 if (SWIG_arg_fail(1)) SWIG_fail;
8230 {
8231 PyThreadState* __tstate = wxPyBeginAllowThreads();
8232 result = wxNativeFontInfo___str__(arg1);
8233
8234 wxPyEndAllowThreads(__tstate);
8235 if (PyErr_Occurred()) SWIG_fail;
8236 }
8237 {
8238 #if wxUSE_UNICODE
8239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8240 #else
8241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8242 #endif
8243 }
8244 return resultobj;
8245 fail:
8246 return NULL;
8247 }
8248
8249
8250 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8251 PyObject *resultobj;
8252 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8253 wxString *arg2 = 0 ;
8254 bool result;
8255 bool temp2 = false ;
8256 PyObject * obj0 = 0 ;
8257 PyObject * obj1 = 0 ;
8258 char *kwnames[] = {
8259 (char *) "self",(char *) "s", NULL
8260 };
8261
8262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8264 if (SWIG_arg_fail(1)) SWIG_fail;
8265 {
8266 arg2 = wxString_in_helper(obj1);
8267 if (arg2 == NULL) SWIG_fail;
8268 temp2 = true;
8269 }
8270 {
8271 PyThreadState* __tstate = wxPyBeginAllowThreads();
8272 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8273
8274 wxPyEndAllowThreads(__tstate);
8275 if (PyErr_Occurred()) SWIG_fail;
8276 }
8277 {
8278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8279 }
8280 {
8281 if (temp2)
8282 delete arg2;
8283 }
8284 return resultobj;
8285 fail:
8286 {
8287 if (temp2)
8288 delete arg2;
8289 }
8290 return NULL;
8291 }
8292
8293
8294 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8295 PyObject *resultobj;
8296 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8297 wxString result;
8298 PyObject * obj0 = 0 ;
8299 char *kwnames[] = {
8300 (char *) "self", NULL
8301 };
8302
8303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8305 if (SWIG_arg_fail(1)) SWIG_fail;
8306 {
8307 PyThreadState* __tstate = wxPyBeginAllowThreads();
8308 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8309
8310 wxPyEndAllowThreads(__tstate);
8311 if (PyErr_Occurred()) SWIG_fail;
8312 }
8313 {
8314 #if wxUSE_UNICODE
8315 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8316 #else
8317 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8318 #endif
8319 }
8320 return resultobj;
8321 fail:
8322 return NULL;
8323 }
8324
8325
8326 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8327 PyObject *obj;
8328 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8329 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8330 Py_INCREF(obj);
8331 return Py_BuildValue((char *)"");
8332 }
8333 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8334 PyObject *resultobj;
8335 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8336 wxString *arg2 = (wxString *) 0 ;
8337 bool temp2 = false ;
8338 PyObject * obj0 = 0 ;
8339 PyObject * obj1 = 0 ;
8340 char *kwnames[] = {
8341 (char *) "self",(char *) "facename", NULL
8342 };
8343
8344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8346 if (SWIG_arg_fail(1)) SWIG_fail;
8347 {
8348 arg2 = wxString_in_helper(obj1);
8349 if (arg2 == NULL) SWIG_fail;
8350 temp2 = true;
8351 }
8352 if (arg1) (arg1)->facename = *arg2;
8353
8354 Py_INCREF(Py_None); resultobj = Py_None;
8355 {
8356 if (temp2)
8357 delete arg2;
8358 }
8359 return resultobj;
8360 fail:
8361 {
8362 if (temp2)
8363 delete arg2;
8364 }
8365 return NULL;
8366 }
8367
8368
8369 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8370 PyObject *resultobj;
8371 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8372 wxString *result;
8373 PyObject * obj0 = 0 ;
8374 char *kwnames[] = {
8375 (char *) "self", NULL
8376 };
8377
8378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
8379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8380 if (SWIG_arg_fail(1)) SWIG_fail;
8381 result = (wxString *)& ((arg1)->facename);
8382
8383 {
8384 #if wxUSE_UNICODE
8385 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8386 #else
8387 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8388 #endif
8389 }
8390 return resultobj;
8391 fail:
8392 return NULL;
8393 }
8394
8395
8396 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8397 PyObject *resultobj;
8398 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8399 wxFontEncoding arg2 ;
8400 PyObject * obj0 = 0 ;
8401 PyObject * obj1 = 0 ;
8402 char *kwnames[] = {
8403 (char *) "self",(char *) "encoding", NULL
8404 };
8405
8406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) 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 {
8410 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8411 if (SWIG_arg_fail(2)) SWIG_fail;
8412 }
8413 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
8414
8415 Py_INCREF(Py_None); resultobj = Py_None;
8416 return resultobj;
8417 fail:
8418 return NULL;
8419 }
8420
8421
8422 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
8423 PyObject *resultobj;
8424 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8425 wxFontEncoding result;
8426 PyObject * obj0 = 0 ;
8427 char *kwnames[] = {
8428 (char *) "self", NULL
8429 };
8430
8431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
8432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8433 if (SWIG_arg_fail(1)) SWIG_fail;
8434 result = (wxFontEncoding) ((arg1)->encoding);
8435
8436 resultobj = SWIG_From_int((result));
8437 return resultobj;
8438 fail:
8439 return NULL;
8440 }
8441
8442
8443 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8444 PyObject *resultobj;
8445 wxNativeEncodingInfo *result;
8446 char *kwnames[] = {
8447 NULL
8448 };
8449
8450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
8451 {
8452 PyThreadState* __tstate = wxPyBeginAllowThreads();
8453 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
8454
8455 wxPyEndAllowThreads(__tstate);
8456 if (PyErr_Occurred()) SWIG_fail;
8457 }
8458 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
8459 return resultobj;
8460 fail:
8461 return NULL;
8462 }
8463
8464
8465 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8466 PyObject *resultobj;
8467 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8468 PyObject * obj0 = 0 ;
8469 char *kwnames[] = {
8470 (char *) "self", NULL
8471 };
8472
8473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
8474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8475 if (SWIG_arg_fail(1)) SWIG_fail;
8476 {
8477 PyThreadState* __tstate = wxPyBeginAllowThreads();
8478 delete arg1;
8479
8480 wxPyEndAllowThreads(__tstate);
8481 if (PyErr_Occurred()) SWIG_fail;
8482 }
8483 Py_INCREF(Py_None); resultobj = Py_None;
8484 return resultobj;
8485 fail:
8486 return NULL;
8487 }
8488
8489
8490 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8491 PyObject *resultobj;
8492 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8493 wxString *arg2 = 0 ;
8494 bool result;
8495 bool temp2 = false ;
8496 PyObject * obj0 = 0 ;
8497 PyObject * obj1 = 0 ;
8498 char *kwnames[] = {
8499 (char *) "self",(char *) "s", NULL
8500 };
8501
8502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8504 if (SWIG_arg_fail(1)) SWIG_fail;
8505 {
8506 arg2 = wxString_in_helper(obj1);
8507 if (arg2 == NULL) SWIG_fail;
8508 temp2 = true;
8509 }
8510 {
8511 PyThreadState* __tstate = wxPyBeginAllowThreads();
8512 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8513
8514 wxPyEndAllowThreads(__tstate);
8515 if (PyErr_Occurred()) SWIG_fail;
8516 }
8517 {
8518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8519 }
8520 {
8521 if (temp2)
8522 delete arg2;
8523 }
8524 return resultobj;
8525 fail:
8526 {
8527 if (temp2)
8528 delete arg2;
8529 }
8530 return NULL;
8531 }
8532
8533
8534 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8535 PyObject *resultobj;
8536 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8537 wxString result;
8538 PyObject * obj0 = 0 ;
8539 char *kwnames[] = {
8540 (char *) "self", NULL
8541 };
8542
8543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
8544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8545 if (SWIG_arg_fail(1)) SWIG_fail;
8546 {
8547 PyThreadState* __tstate = wxPyBeginAllowThreads();
8548 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
8549
8550 wxPyEndAllowThreads(__tstate);
8551 if (PyErr_Occurred()) SWIG_fail;
8552 }
8553 {
8554 #if wxUSE_UNICODE
8555 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8556 #else
8557 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8558 #endif
8559 }
8560 return resultobj;
8561 fail:
8562 return NULL;
8563 }
8564
8565
8566 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
8567 PyObject *obj;
8568 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8569 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
8570 Py_INCREF(obj);
8571 return Py_BuildValue((char *)"");
8572 }
8573 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8574 PyObject *resultobj;
8575 wxFontEncoding arg1 ;
8576 wxNativeEncodingInfo *result;
8577 PyObject * obj0 = 0 ;
8578 char *kwnames[] = {
8579 (char *) "encoding", NULL
8580 };
8581
8582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
8583 {
8584 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8585 if (SWIG_arg_fail(1)) SWIG_fail;
8586 }
8587 {
8588 PyThreadState* __tstate = wxPyBeginAllowThreads();
8589 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
8590
8591 wxPyEndAllowThreads(__tstate);
8592 if (PyErr_Occurred()) SWIG_fail;
8593 }
8594 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
8595 return resultobj;
8596 fail:
8597 return NULL;
8598 }
8599
8600
8601 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8602 PyObject *resultobj;
8603 wxNativeEncodingInfo *arg1 = 0 ;
8604 bool result;
8605 PyObject * obj0 = 0 ;
8606 char *kwnames[] = {
8607 (char *) "info", NULL
8608 };
8609
8610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
8611 {
8612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8613 if (SWIG_arg_fail(1)) SWIG_fail;
8614 if (arg1 == NULL) {
8615 SWIG_null_ref("wxNativeEncodingInfo");
8616 }
8617 if (SWIG_arg_fail(1)) SWIG_fail;
8618 }
8619 {
8620 PyThreadState* __tstate = wxPyBeginAllowThreads();
8621 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
8622
8623 wxPyEndAllowThreads(__tstate);
8624 if (PyErr_Occurred()) SWIG_fail;
8625 }
8626 {
8627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8628 }
8629 return resultobj;
8630 fail:
8631 return NULL;
8632 }
8633
8634
8635 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8636 PyObject *resultobj;
8637 wxFontMapper *result;
8638 char *kwnames[] = {
8639 NULL
8640 };
8641
8642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
8643 {
8644 PyThreadState* __tstate = wxPyBeginAllowThreads();
8645 result = (wxFontMapper *)new wxFontMapper();
8646
8647 wxPyEndAllowThreads(__tstate);
8648 if (PyErr_Occurred()) SWIG_fail;
8649 }
8650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
8651 return resultobj;
8652 fail:
8653 return NULL;
8654 }
8655
8656
8657 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8658 PyObject *resultobj;
8659 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8660 PyObject * obj0 = 0 ;
8661 char *kwnames[] = {
8662 (char *) "self", NULL
8663 };
8664
8665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
8666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8667 if (SWIG_arg_fail(1)) SWIG_fail;
8668 {
8669 PyThreadState* __tstate = wxPyBeginAllowThreads();
8670 delete arg1;
8671
8672 wxPyEndAllowThreads(__tstate);
8673 if (PyErr_Occurred()) SWIG_fail;
8674 }
8675 Py_INCREF(Py_None); resultobj = Py_None;
8676 return resultobj;
8677 fail:
8678 return NULL;
8679 }
8680
8681
8682 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
8683 PyObject *resultobj;
8684 wxFontMapper *result;
8685 char *kwnames[] = {
8686 NULL
8687 };
8688
8689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
8690 {
8691 PyThreadState* __tstate = wxPyBeginAllowThreads();
8692 result = (wxFontMapper *)wxFontMapper::Get();
8693
8694 wxPyEndAllowThreads(__tstate);
8695 if (PyErr_Occurred()) SWIG_fail;
8696 }
8697 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8698 return resultobj;
8699 fail:
8700 return NULL;
8701 }
8702
8703
8704 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
8705 PyObject *resultobj;
8706 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8707 wxFontMapper *result;
8708 PyObject * obj0 = 0 ;
8709 char *kwnames[] = {
8710 (char *) "mapper", NULL
8711 };
8712
8713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
8714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8715 if (SWIG_arg_fail(1)) SWIG_fail;
8716 {
8717 PyThreadState* __tstate = wxPyBeginAllowThreads();
8718 result = (wxFontMapper *)wxFontMapper::Set(arg1);
8719
8720 wxPyEndAllowThreads(__tstate);
8721 if (PyErr_Occurred()) SWIG_fail;
8722 }
8723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8724 return resultobj;
8725 fail:
8726 return NULL;
8727 }
8728
8729
8730 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8731 PyObject *resultobj;
8732 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8733 wxString *arg2 = 0 ;
8734 bool arg3 = (bool) true ;
8735 wxFontEncoding result;
8736 bool temp2 = false ;
8737 PyObject * obj0 = 0 ;
8738 PyObject * obj1 = 0 ;
8739 PyObject * obj2 = 0 ;
8740 char *kwnames[] = {
8741 (char *) "self",(char *) "charset",(char *) "interactive", NULL
8742 };
8743
8744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
8745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8746 if (SWIG_arg_fail(1)) SWIG_fail;
8747 {
8748 arg2 = wxString_in_helper(obj1);
8749 if (arg2 == NULL) SWIG_fail;
8750 temp2 = true;
8751 }
8752 if (obj2) {
8753 {
8754 arg3 = (bool)(SWIG_As_bool(obj2));
8755 if (SWIG_arg_fail(3)) SWIG_fail;
8756 }
8757 }
8758 {
8759 PyThreadState* __tstate = wxPyBeginAllowThreads();
8760 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
8761
8762 wxPyEndAllowThreads(__tstate);
8763 if (PyErr_Occurred()) SWIG_fail;
8764 }
8765 resultobj = SWIG_From_int((result));
8766 {
8767 if (temp2)
8768 delete arg2;
8769 }
8770 return resultobj;
8771 fail:
8772 {
8773 if (temp2)
8774 delete arg2;
8775 }
8776 return NULL;
8777 }
8778
8779
8780 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
8781 PyObject *resultobj;
8782 size_t result;
8783 char *kwnames[] = {
8784 NULL
8785 };
8786
8787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
8788 {
8789 PyThreadState* __tstate = wxPyBeginAllowThreads();
8790 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
8791
8792 wxPyEndAllowThreads(__tstate);
8793 if (PyErr_Occurred()) SWIG_fail;
8794 }
8795 {
8796 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8797 }
8798 return resultobj;
8799 fail:
8800 return NULL;
8801 }
8802
8803
8804 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8805 PyObject *resultobj;
8806 size_t arg1 ;
8807 wxFontEncoding result;
8808 PyObject * obj0 = 0 ;
8809 char *kwnames[] = {
8810 (char *) "n", NULL
8811 };
8812
8813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
8814 {
8815 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8816 if (SWIG_arg_fail(1)) SWIG_fail;
8817 }
8818 {
8819 PyThreadState* __tstate = wxPyBeginAllowThreads();
8820 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
8821
8822 wxPyEndAllowThreads(__tstate);
8823 if (PyErr_Occurred()) SWIG_fail;
8824 }
8825 resultobj = SWIG_From_int((result));
8826 return resultobj;
8827 fail:
8828 return NULL;
8829 }
8830
8831
8832 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
8833 PyObject *resultobj;
8834 wxFontEncoding arg1 ;
8835 wxString result;
8836 PyObject * obj0 = 0 ;
8837 char *kwnames[] = {
8838 (char *) "encoding", NULL
8839 };
8840
8841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
8842 {
8843 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8844 if (SWIG_arg_fail(1)) SWIG_fail;
8845 }
8846 {
8847 PyThreadState* __tstate = wxPyBeginAllowThreads();
8848 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
8849
8850 wxPyEndAllowThreads(__tstate);
8851 if (PyErr_Occurred()) SWIG_fail;
8852 }
8853 {
8854 #if wxUSE_UNICODE
8855 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8856 #else
8857 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8858 #endif
8859 }
8860 return resultobj;
8861 fail:
8862 return NULL;
8863 }
8864
8865
8866 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
8867 PyObject *resultobj;
8868 wxFontEncoding arg1 ;
8869 wxString result;
8870 PyObject * obj0 = 0 ;
8871 char *kwnames[] = {
8872 (char *) "encoding", NULL
8873 };
8874
8875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
8876 {
8877 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8878 if (SWIG_arg_fail(1)) SWIG_fail;
8879 }
8880 {
8881 PyThreadState* __tstate = wxPyBeginAllowThreads();
8882 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
8883
8884 wxPyEndAllowThreads(__tstate);
8885 if (PyErr_Occurred()) SWIG_fail;
8886 }
8887 {
8888 #if wxUSE_UNICODE
8889 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8890 #else
8891 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8892 #endif
8893 }
8894 return resultobj;
8895 fail:
8896 return NULL;
8897 }
8898
8899
8900 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
8901 PyObject *resultobj;
8902 wxString *arg1 = 0 ;
8903 wxFontEncoding result;
8904 bool temp1 = false ;
8905 PyObject * obj0 = 0 ;
8906 char *kwnames[] = {
8907 (char *) "name", NULL
8908 };
8909
8910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
8911 {
8912 arg1 = wxString_in_helper(obj0);
8913 if (arg1 == NULL) SWIG_fail;
8914 temp1 = true;
8915 }
8916 {
8917 PyThreadState* __tstate = wxPyBeginAllowThreads();
8918 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
8919
8920 wxPyEndAllowThreads(__tstate);
8921 if (PyErr_Occurred()) SWIG_fail;
8922 }
8923 resultobj = SWIG_From_int((result));
8924 {
8925 if (temp1)
8926 delete arg1;
8927 }
8928 return resultobj;
8929 fail:
8930 {
8931 if (temp1)
8932 delete arg1;
8933 }
8934 return NULL;
8935 }
8936
8937
8938 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
8939 PyObject *resultobj;
8940 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8941 wxConfigBase *arg2 = (wxConfigBase *) 0 ;
8942 PyObject * obj0 = 0 ;
8943 PyObject * obj1 = 0 ;
8944 char *kwnames[] = {
8945 (char *) "self",(char *) "config", NULL
8946 };
8947
8948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
8949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8950 if (SWIG_arg_fail(1)) SWIG_fail;
8951 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8952 if (SWIG_arg_fail(2)) SWIG_fail;
8953 {
8954 PyThreadState* __tstate = wxPyBeginAllowThreads();
8955 (arg1)->SetConfig(arg2);
8956
8957 wxPyEndAllowThreads(__tstate);
8958 if (PyErr_Occurred()) SWIG_fail;
8959 }
8960 Py_INCREF(Py_None); resultobj = Py_None;
8961 return resultobj;
8962 fail:
8963 return NULL;
8964 }
8965
8966
8967 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8968 PyObject *resultobj;
8969 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8970 wxString *arg2 = 0 ;
8971 bool temp2 = false ;
8972 PyObject * obj0 = 0 ;
8973 PyObject * obj1 = 0 ;
8974 char *kwnames[] = {
8975 (char *) "self",(char *) "prefix", NULL
8976 };
8977
8978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
8979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8980 if (SWIG_arg_fail(1)) SWIG_fail;
8981 {
8982 arg2 = wxString_in_helper(obj1);
8983 if (arg2 == NULL) SWIG_fail;
8984 temp2 = true;
8985 }
8986 {
8987 PyThreadState* __tstate = wxPyBeginAllowThreads();
8988 (arg1)->SetConfigPath((wxString const &)*arg2);
8989
8990 wxPyEndAllowThreads(__tstate);
8991 if (PyErr_Occurred()) SWIG_fail;
8992 }
8993 Py_INCREF(Py_None); resultobj = Py_None;
8994 {
8995 if (temp2)
8996 delete arg2;
8997 }
8998 return resultobj;
8999 fail:
9000 {
9001 if (temp2)
9002 delete arg2;
9003 }
9004 return NULL;
9005 }
9006
9007
9008 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
9009 PyObject *resultobj;
9010 wxString result;
9011 char *kwnames[] = {
9012 NULL
9013 };
9014
9015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
9016 {
9017 PyThreadState* __tstate = wxPyBeginAllowThreads();
9018 result = wxFontMapper::GetDefaultConfigPath();
9019
9020 wxPyEndAllowThreads(__tstate);
9021 if (PyErr_Occurred()) SWIG_fail;
9022 }
9023 {
9024 #if wxUSE_UNICODE
9025 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9026 #else
9027 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9028 #endif
9029 }
9030 return resultobj;
9031 fail:
9032 return NULL;
9033 }
9034
9035
9036 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9037 PyObject *resultobj;
9038 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9039 wxFontEncoding arg2 ;
9040 wxString const &arg3_defvalue = wxPyEmptyString ;
9041 wxString *arg3 = (wxString *) &arg3_defvalue ;
9042 bool arg4 = (bool) true ;
9043 PyObject *result;
9044 bool temp3 = false ;
9045 PyObject * obj0 = 0 ;
9046 PyObject * obj1 = 0 ;
9047 PyObject * obj2 = 0 ;
9048 PyObject * obj3 = 0 ;
9049 char *kwnames[] = {
9050 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
9051 };
9052
9053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9055 if (SWIG_arg_fail(1)) SWIG_fail;
9056 {
9057 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9058 if (SWIG_arg_fail(2)) SWIG_fail;
9059 }
9060 if (obj2) {
9061 {
9062 arg3 = wxString_in_helper(obj2);
9063 if (arg3 == NULL) SWIG_fail;
9064 temp3 = true;
9065 }
9066 }
9067 if (obj3) {
9068 {
9069 arg4 = (bool)(SWIG_As_bool(obj3));
9070 if (SWIG_arg_fail(4)) SWIG_fail;
9071 }
9072 }
9073 {
9074 PyThreadState* __tstate = wxPyBeginAllowThreads();
9075 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9076
9077 wxPyEndAllowThreads(__tstate);
9078 if (PyErr_Occurred()) SWIG_fail;
9079 }
9080 resultobj = result;
9081 {
9082 if (temp3)
9083 delete arg3;
9084 }
9085 return resultobj;
9086 fail:
9087 {
9088 if (temp3)
9089 delete arg3;
9090 }
9091 return NULL;
9092 }
9093
9094
9095 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9096 PyObject *resultobj;
9097 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9098 wxFontEncoding arg2 ;
9099 wxString const &arg3_defvalue = wxPyEmptyString ;
9100 wxString *arg3 = (wxString *) &arg3_defvalue ;
9101 bool result;
9102 bool temp3 = false ;
9103 PyObject * obj0 = 0 ;
9104 PyObject * obj1 = 0 ;
9105 PyObject * obj2 = 0 ;
9106 char *kwnames[] = {
9107 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9108 };
9109
9110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9112 if (SWIG_arg_fail(1)) SWIG_fail;
9113 {
9114 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9115 if (SWIG_arg_fail(2)) SWIG_fail;
9116 }
9117 if (obj2) {
9118 {
9119 arg3 = wxString_in_helper(obj2);
9120 if (arg3 == NULL) SWIG_fail;
9121 temp3 = true;
9122 }
9123 }
9124 {
9125 PyThreadState* __tstate = wxPyBeginAllowThreads();
9126 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9127
9128 wxPyEndAllowThreads(__tstate);
9129 if (PyErr_Occurred()) SWIG_fail;
9130 }
9131 {
9132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9133 }
9134 {
9135 if (temp3)
9136 delete arg3;
9137 }
9138 return resultobj;
9139 fail:
9140 {
9141 if (temp3)
9142 delete arg3;
9143 }
9144 return NULL;
9145 }
9146
9147
9148 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9149 PyObject *resultobj;
9150 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9151 wxWindow *arg2 = (wxWindow *) 0 ;
9152 PyObject * obj0 = 0 ;
9153 PyObject * obj1 = 0 ;
9154 char *kwnames[] = {
9155 (char *) "self",(char *) "parent", NULL
9156 };
9157
9158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9160 if (SWIG_arg_fail(1)) SWIG_fail;
9161 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9162 if (SWIG_arg_fail(2)) SWIG_fail;
9163 {
9164 PyThreadState* __tstate = wxPyBeginAllowThreads();
9165 (arg1)->SetDialogParent(arg2);
9166
9167 wxPyEndAllowThreads(__tstate);
9168 if (PyErr_Occurred()) SWIG_fail;
9169 }
9170 Py_INCREF(Py_None); resultobj = Py_None;
9171 return resultobj;
9172 fail:
9173 return NULL;
9174 }
9175
9176
9177 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9178 PyObject *resultobj;
9179 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9180 wxString *arg2 = 0 ;
9181 bool temp2 = false ;
9182 PyObject * obj0 = 0 ;
9183 PyObject * obj1 = 0 ;
9184 char *kwnames[] = {
9185 (char *) "self",(char *) "title", NULL
9186 };
9187
9188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9190 if (SWIG_arg_fail(1)) SWIG_fail;
9191 {
9192 arg2 = wxString_in_helper(obj1);
9193 if (arg2 == NULL) SWIG_fail;
9194 temp2 = true;
9195 }
9196 {
9197 PyThreadState* __tstate = wxPyBeginAllowThreads();
9198 (arg1)->SetDialogTitle((wxString const &)*arg2);
9199
9200 wxPyEndAllowThreads(__tstate);
9201 if (PyErr_Occurred()) SWIG_fail;
9202 }
9203 Py_INCREF(Py_None); resultobj = Py_None;
9204 {
9205 if (temp2)
9206 delete arg2;
9207 }
9208 return resultobj;
9209 fail:
9210 {
9211 if (temp2)
9212 delete arg2;
9213 }
9214 return NULL;
9215 }
9216
9217
9218 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9219 PyObject *obj;
9220 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9221 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9222 Py_INCREF(obj);
9223 return Py_BuildValue((char *)"");
9224 }
9225 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9226 PyObject *resultobj;
9227 int arg1 ;
9228 int arg2 ;
9229 int arg3 ;
9230 int arg4 ;
9231 bool arg5 = (bool) false ;
9232 wxString const &arg6_defvalue = wxPyEmptyString ;
9233 wxString *arg6 = (wxString *) &arg6_defvalue ;
9234 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9235 wxFont *result;
9236 bool temp6 = false ;
9237 PyObject * obj0 = 0 ;
9238 PyObject * obj1 = 0 ;
9239 PyObject * obj2 = 0 ;
9240 PyObject * obj3 = 0 ;
9241 PyObject * obj4 = 0 ;
9242 PyObject * obj5 = 0 ;
9243 PyObject * obj6 = 0 ;
9244 char *kwnames[] = {
9245 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9246 };
9247
9248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9249 {
9250 arg1 = (int)(SWIG_As_int(obj0));
9251 if (SWIG_arg_fail(1)) SWIG_fail;
9252 }
9253 {
9254 arg2 = (int)(SWIG_As_int(obj1));
9255 if (SWIG_arg_fail(2)) SWIG_fail;
9256 }
9257 {
9258 arg3 = (int)(SWIG_As_int(obj2));
9259 if (SWIG_arg_fail(3)) SWIG_fail;
9260 }
9261 {
9262 arg4 = (int)(SWIG_As_int(obj3));
9263 if (SWIG_arg_fail(4)) SWIG_fail;
9264 }
9265 if (obj4) {
9266 {
9267 arg5 = (bool)(SWIG_As_bool(obj4));
9268 if (SWIG_arg_fail(5)) SWIG_fail;
9269 }
9270 }
9271 if (obj5) {
9272 {
9273 arg6 = wxString_in_helper(obj5);
9274 if (arg6 == NULL) SWIG_fail;
9275 temp6 = true;
9276 }
9277 }
9278 if (obj6) {
9279 {
9280 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9281 if (SWIG_arg_fail(7)) SWIG_fail;
9282 }
9283 }
9284 {
9285 if (!wxPyCheckForApp()) SWIG_fail;
9286 PyThreadState* __tstate = wxPyBeginAllowThreads();
9287 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9288
9289 wxPyEndAllowThreads(__tstate);
9290 if (PyErr_Occurred()) SWIG_fail;
9291 }
9292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9293 {
9294 if (temp6)
9295 delete arg6;
9296 }
9297 return resultobj;
9298 fail:
9299 {
9300 if (temp6)
9301 delete arg6;
9302 }
9303 return NULL;
9304 }
9305
9306
9307 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9308 PyObject *resultobj;
9309 wxFont *arg1 = (wxFont *) 0 ;
9310 PyObject * obj0 = 0 ;
9311 char *kwnames[] = {
9312 (char *) "self", NULL
9313 };
9314
9315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9317 if (SWIG_arg_fail(1)) SWIG_fail;
9318 {
9319 PyThreadState* __tstate = wxPyBeginAllowThreads();
9320 delete arg1;
9321
9322 wxPyEndAllowThreads(__tstate);
9323 if (PyErr_Occurred()) SWIG_fail;
9324 }
9325 Py_INCREF(Py_None); resultobj = Py_None;
9326 return resultobj;
9327 fail:
9328 return NULL;
9329 }
9330
9331
9332 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9333 PyObject *resultobj;
9334 wxNativeFontInfo *arg1 = 0 ;
9335 wxFont *result;
9336 PyObject * obj0 = 0 ;
9337 char *kwnames[] = {
9338 (char *) "info", NULL
9339 };
9340
9341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9342 {
9343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9344 if (SWIG_arg_fail(1)) SWIG_fail;
9345 if (arg1 == NULL) {
9346 SWIG_null_ref("wxNativeFontInfo");
9347 }
9348 if (SWIG_arg_fail(1)) SWIG_fail;
9349 }
9350 {
9351 if (!wxPyCheckForApp()) SWIG_fail;
9352 PyThreadState* __tstate = wxPyBeginAllowThreads();
9353 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9354
9355 wxPyEndAllowThreads(__tstate);
9356 if (PyErr_Occurred()) SWIG_fail;
9357 }
9358 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9359 return resultobj;
9360 fail:
9361 return NULL;
9362 }
9363
9364
9365 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9366 PyObject *resultobj;
9367 wxString *arg1 = 0 ;
9368 wxFont *result;
9369 bool temp1 = false ;
9370 PyObject * obj0 = 0 ;
9371 char *kwnames[] = {
9372 (char *) "info", NULL
9373 };
9374
9375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9376 {
9377 arg1 = wxString_in_helper(obj0);
9378 if (arg1 == NULL) SWIG_fail;
9379 temp1 = true;
9380 }
9381 {
9382 if (!wxPyCheckForApp()) SWIG_fail;
9383 PyThreadState* __tstate = wxPyBeginAllowThreads();
9384 result = (wxFont *)new_wxFont((wxString const &)*arg1);
9385
9386 wxPyEndAllowThreads(__tstate);
9387 if (PyErr_Occurred()) SWIG_fail;
9388 }
9389 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9390 {
9391 if (temp1)
9392 delete arg1;
9393 }
9394 return resultobj;
9395 fail:
9396 {
9397 if (temp1)
9398 delete arg1;
9399 }
9400 return NULL;
9401 }
9402
9403
9404 static PyObject *_wrap_new_FFont(PyObject *, PyObject *args, PyObject *kwargs) {
9405 PyObject *resultobj;
9406 int arg1 ;
9407 wxFontFamily arg2 ;
9408 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9409 wxString const &arg4_defvalue = wxPyEmptyString ;
9410 wxString *arg4 = (wxString *) &arg4_defvalue ;
9411 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9412 wxFont *result;
9413 bool temp4 = false ;
9414 PyObject * obj0 = 0 ;
9415 PyObject * obj1 = 0 ;
9416 PyObject * obj2 = 0 ;
9417 PyObject * obj3 = 0 ;
9418 PyObject * obj4 = 0 ;
9419 char *kwnames[] = {
9420 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9421 };
9422
9423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9424 {
9425 arg1 = (int)(SWIG_As_int(obj0));
9426 if (SWIG_arg_fail(1)) SWIG_fail;
9427 }
9428 {
9429 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9430 if (SWIG_arg_fail(2)) SWIG_fail;
9431 }
9432 if (obj2) {
9433 {
9434 arg3 = (int)(SWIG_As_int(obj2));
9435 if (SWIG_arg_fail(3)) SWIG_fail;
9436 }
9437 }
9438 if (obj3) {
9439 {
9440 arg4 = wxString_in_helper(obj3);
9441 if (arg4 == NULL) SWIG_fail;
9442 temp4 = true;
9443 }
9444 }
9445 if (obj4) {
9446 {
9447 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9448 if (SWIG_arg_fail(5)) SWIG_fail;
9449 }
9450 }
9451 {
9452 if (!wxPyCheckForApp()) SWIG_fail;
9453 PyThreadState* __tstate = wxPyBeginAllowThreads();
9454 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9455
9456 wxPyEndAllowThreads(__tstate);
9457 if (PyErr_Occurred()) SWIG_fail;
9458 }
9459 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9460 {
9461 if (temp4)
9462 delete arg4;
9463 }
9464 return resultobj;
9465 fail:
9466 {
9467 if (temp4)
9468 delete arg4;
9469 }
9470 return NULL;
9471 }
9472
9473
9474 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9475 PyObject *resultobj;
9476 wxSize *arg1 = 0 ;
9477 int arg2 ;
9478 int arg3 ;
9479 int arg4 ;
9480 bool arg5 = (bool) false ;
9481 wxString const &arg6_defvalue = wxEmptyString ;
9482 wxString *arg6 = (wxString *) &arg6_defvalue ;
9483 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9484 wxFont *result;
9485 wxSize temp1 ;
9486 bool temp6 = false ;
9487 PyObject * obj0 = 0 ;
9488 PyObject * obj1 = 0 ;
9489 PyObject * obj2 = 0 ;
9490 PyObject * obj3 = 0 ;
9491 PyObject * obj4 = 0 ;
9492 PyObject * obj5 = 0 ;
9493 PyObject * obj6 = 0 ;
9494 char *kwnames[] = {
9495 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
9496 };
9497
9498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9499 {
9500 arg1 = &temp1;
9501 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9502 }
9503 {
9504 arg2 = (int)(SWIG_As_int(obj1));
9505 if (SWIG_arg_fail(2)) SWIG_fail;
9506 }
9507 {
9508 arg3 = (int)(SWIG_As_int(obj2));
9509 if (SWIG_arg_fail(3)) SWIG_fail;
9510 }
9511 {
9512 arg4 = (int)(SWIG_As_int(obj3));
9513 if (SWIG_arg_fail(4)) SWIG_fail;
9514 }
9515 if (obj4) {
9516 {
9517 arg5 = (bool)(SWIG_As_bool(obj4));
9518 if (SWIG_arg_fail(5)) SWIG_fail;
9519 }
9520 }
9521 if (obj5) {
9522 {
9523 arg6 = wxString_in_helper(obj5);
9524 if (arg6 == NULL) SWIG_fail;
9525 temp6 = true;
9526 }
9527 }
9528 if (obj6) {
9529 {
9530 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9531 if (SWIG_arg_fail(7)) SWIG_fail;
9532 }
9533 }
9534 {
9535 if (!wxPyCheckForApp()) SWIG_fail;
9536 PyThreadState* __tstate = wxPyBeginAllowThreads();
9537 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9538
9539 wxPyEndAllowThreads(__tstate);
9540 if (PyErr_Occurred()) SWIG_fail;
9541 }
9542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9543 {
9544 if (temp6)
9545 delete arg6;
9546 }
9547 return resultobj;
9548 fail:
9549 {
9550 if (temp6)
9551 delete arg6;
9552 }
9553 return NULL;
9554 }
9555
9556
9557 static PyObject *_wrap_new_FFontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9558 PyObject *resultobj;
9559 wxSize *arg1 = 0 ;
9560 wxFontFamily arg2 ;
9561 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9562 wxString const &arg4_defvalue = wxEmptyString ;
9563 wxString *arg4 = (wxString *) &arg4_defvalue ;
9564 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9565 wxFont *result;
9566 wxSize temp1 ;
9567 bool temp4 = false ;
9568 PyObject * obj0 = 0 ;
9569 PyObject * obj1 = 0 ;
9570 PyObject * obj2 = 0 ;
9571 PyObject * obj3 = 0 ;
9572 PyObject * obj4 = 0 ;
9573 char *kwnames[] = {
9574 (char *) "pixelSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9575 };
9576
9577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9578 {
9579 arg1 = &temp1;
9580 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9581 }
9582 {
9583 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9584 if (SWIG_arg_fail(2)) SWIG_fail;
9585 }
9586 if (obj2) {
9587 {
9588 arg3 = (int)(SWIG_As_int(obj2));
9589 if (SWIG_arg_fail(3)) SWIG_fail;
9590 }
9591 }
9592 if (obj3) {
9593 {
9594 arg4 = wxString_in_helper(obj3);
9595 if (arg4 == NULL) SWIG_fail;
9596 temp4 = true;
9597 }
9598 }
9599 if (obj4) {
9600 {
9601 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9602 if (SWIG_arg_fail(5)) SWIG_fail;
9603 }
9604 }
9605 {
9606 if (!wxPyCheckForApp()) SWIG_fail;
9607 PyThreadState* __tstate = wxPyBeginAllowThreads();
9608 result = (wxFont *)new_wxFont((wxSize const &)*arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9609
9610 wxPyEndAllowThreads(__tstate);
9611 if (PyErr_Occurred()) SWIG_fail;
9612 }
9613 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9614 {
9615 if (temp4)
9616 delete arg4;
9617 }
9618 return resultobj;
9619 fail:
9620 {
9621 if (temp4)
9622 delete arg4;
9623 }
9624 return NULL;
9625 }
9626
9627
9628 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
9629 PyObject *resultobj;
9630 wxFont *arg1 = (wxFont *) 0 ;
9631 bool result;
9632 PyObject * obj0 = 0 ;
9633 char *kwnames[] = {
9634 (char *) "self", NULL
9635 };
9636
9637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
9638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9639 if (SWIG_arg_fail(1)) SWIG_fail;
9640 {
9641 PyThreadState* __tstate = wxPyBeginAllowThreads();
9642 result = (bool)((wxFont const *)arg1)->Ok();
9643
9644 wxPyEndAllowThreads(__tstate);
9645 if (PyErr_Occurred()) SWIG_fail;
9646 }
9647 {
9648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9649 }
9650 return resultobj;
9651 fail:
9652 return NULL;
9653 }
9654
9655
9656 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9657 PyObject *resultobj;
9658 wxFont *arg1 = (wxFont *) 0 ;
9659 wxFont *arg2 = (wxFont *) 0 ;
9660 bool result;
9661 PyObject * obj0 = 0 ;
9662 PyObject * obj1 = 0 ;
9663 char *kwnames[] = {
9664 (char *) "self",(char *) "other", NULL
9665 };
9666
9667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
9668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9669 if (SWIG_arg_fail(1)) SWIG_fail;
9670 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9671 if (SWIG_arg_fail(2)) SWIG_fail;
9672 {
9673 PyThreadState* __tstate = wxPyBeginAllowThreads();
9674 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
9675
9676 wxPyEndAllowThreads(__tstate);
9677 if (PyErr_Occurred()) SWIG_fail;
9678 }
9679 {
9680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9681 }
9682 return resultobj;
9683 fail:
9684 return NULL;
9685 }
9686
9687
9688 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9689 PyObject *resultobj;
9690 wxFont *arg1 = (wxFont *) 0 ;
9691 wxFont *arg2 = (wxFont *) 0 ;
9692 bool result;
9693 PyObject * obj0 = 0 ;
9694 PyObject * obj1 = 0 ;
9695 char *kwnames[] = {
9696 (char *) "self",(char *) "other", NULL
9697 };
9698
9699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
9700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9701 if (SWIG_arg_fail(1)) SWIG_fail;
9702 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9703 if (SWIG_arg_fail(2)) SWIG_fail;
9704 {
9705 PyThreadState* __tstate = wxPyBeginAllowThreads();
9706 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
9707
9708 wxPyEndAllowThreads(__tstate);
9709 if (PyErr_Occurred()) SWIG_fail;
9710 }
9711 {
9712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9713 }
9714 return resultobj;
9715 fail:
9716 return NULL;
9717 }
9718
9719
9720 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9721 PyObject *resultobj;
9722 wxFont *arg1 = (wxFont *) 0 ;
9723 int result;
9724 PyObject * obj0 = 0 ;
9725 char *kwnames[] = {
9726 (char *) "self", NULL
9727 };
9728
9729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
9730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9731 if (SWIG_arg_fail(1)) SWIG_fail;
9732 {
9733 PyThreadState* __tstate = wxPyBeginAllowThreads();
9734 result = (int)((wxFont const *)arg1)->GetPointSize();
9735
9736 wxPyEndAllowThreads(__tstate);
9737 if (PyErr_Occurred()) SWIG_fail;
9738 }
9739 {
9740 resultobj = SWIG_From_int((int)(result));
9741 }
9742 return resultobj;
9743 fail:
9744 return NULL;
9745 }
9746
9747
9748 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9749 PyObject *resultobj;
9750 wxFont *arg1 = (wxFont *) 0 ;
9751 wxSize result;
9752 PyObject * obj0 = 0 ;
9753 char *kwnames[] = {
9754 (char *) "self", NULL
9755 };
9756
9757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
9758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9759 if (SWIG_arg_fail(1)) SWIG_fail;
9760 {
9761 PyThreadState* __tstate = wxPyBeginAllowThreads();
9762 result = ((wxFont const *)arg1)->GetPixelSize();
9763
9764 wxPyEndAllowThreads(__tstate);
9765 if (PyErr_Occurred()) SWIG_fail;
9766 }
9767 {
9768 wxSize * resultptr;
9769 resultptr = new wxSize((wxSize &)(result));
9770 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
9771 }
9772 return resultobj;
9773 fail:
9774 return NULL;
9775 }
9776
9777
9778 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
9779 PyObject *resultobj;
9780 wxFont *arg1 = (wxFont *) 0 ;
9781 bool result;
9782 PyObject * obj0 = 0 ;
9783 char *kwnames[] = {
9784 (char *) "self", NULL
9785 };
9786
9787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
9788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9789 if (SWIG_arg_fail(1)) SWIG_fail;
9790 {
9791 PyThreadState* __tstate = wxPyBeginAllowThreads();
9792 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
9793
9794 wxPyEndAllowThreads(__tstate);
9795 if (PyErr_Occurred()) SWIG_fail;
9796 }
9797 {
9798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9799 }
9800 return resultobj;
9801 fail:
9802 return NULL;
9803 }
9804
9805
9806 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
9807 PyObject *resultobj;
9808 wxFont *arg1 = (wxFont *) 0 ;
9809 int result;
9810 PyObject * obj0 = 0 ;
9811 char *kwnames[] = {
9812 (char *) "self", NULL
9813 };
9814
9815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
9816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9817 if (SWIG_arg_fail(1)) SWIG_fail;
9818 {
9819 PyThreadState* __tstate = wxPyBeginAllowThreads();
9820 result = (int)((wxFont const *)arg1)->GetFamily();
9821
9822 wxPyEndAllowThreads(__tstate);
9823 if (PyErr_Occurred()) SWIG_fail;
9824 }
9825 {
9826 resultobj = SWIG_From_int((int)(result));
9827 }
9828 return resultobj;
9829 fail:
9830 return NULL;
9831 }
9832
9833
9834 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
9835 PyObject *resultobj;
9836 wxFont *arg1 = (wxFont *) 0 ;
9837 int result;
9838 PyObject * obj0 = 0 ;
9839 char *kwnames[] = {
9840 (char *) "self", NULL
9841 };
9842
9843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
9844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9845 if (SWIG_arg_fail(1)) SWIG_fail;
9846 {
9847 PyThreadState* __tstate = wxPyBeginAllowThreads();
9848 result = (int)((wxFont const *)arg1)->GetStyle();
9849
9850 wxPyEndAllowThreads(__tstate);
9851 if (PyErr_Occurred()) SWIG_fail;
9852 }
9853 {
9854 resultobj = SWIG_From_int((int)(result));
9855 }
9856 return resultobj;
9857 fail:
9858 return NULL;
9859 }
9860
9861
9862 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
9863 PyObject *resultobj;
9864 wxFont *arg1 = (wxFont *) 0 ;
9865 int result;
9866 PyObject * obj0 = 0 ;
9867 char *kwnames[] = {
9868 (char *) "self", NULL
9869 };
9870
9871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
9872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9873 if (SWIG_arg_fail(1)) SWIG_fail;
9874 {
9875 PyThreadState* __tstate = wxPyBeginAllowThreads();
9876 result = (int)((wxFont const *)arg1)->GetWeight();
9877
9878 wxPyEndAllowThreads(__tstate);
9879 if (PyErr_Occurred()) SWIG_fail;
9880 }
9881 {
9882 resultobj = SWIG_From_int((int)(result));
9883 }
9884 return resultobj;
9885 fail:
9886 return NULL;
9887 }
9888
9889
9890 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
9891 PyObject *resultobj;
9892 wxFont *arg1 = (wxFont *) 0 ;
9893 bool result;
9894 PyObject * obj0 = 0 ;
9895 char *kwnames[] = {
9896 (char *) "self", NULL
9897 };
9898
9899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
9900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9901 if (SWIG_arg_fail(1)) SWIG_fail;
9902 {
9903 PyThreadState* __tstate = wxPyBeginAllowThreads();
9904 result = (bool)((wxFont const *)arg1)->GetUnderlined();
9905
9906 wxPyEndAllowThreads(__tstate);
9907 if (PyErr_Occurred()) SWIG_fail;
9908 }
9909 {
9910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9911 }
9912 return resultobj;
9913 fail:
9914 return NULL;
9915 }
9916
9917
9918 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
9919 PyObject *resultobj;
9920 wxFont *arg1 = (wxFont *) 0 ;
9921 wxString result;
9922 PyObject * obj0 = 0 ;
9923 char *kwnames[] = {
9924 (char *) "self", NULL
9925 };
9926
9927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
9928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9929 if (SWIG_arg_fail(1)) SWIG_fail;
9930 {
9931 PyThreadState* __tstate = wxPyBeginAllowThreads();
9932 result = ((wxFont const *)arg1)->GetFaceName();
9933
9934 wxPyEndAllowThreads(__tstate);
9935 if (PyErr_Occurred()) SWIG_fail;
9936 }
9937 {
9938 #if wxUSE_UNICODE
9939 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9940 #else
9941 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9942 #endif
9943 }
9944 return resultobj;
9945 fail:
9946 return NULL;
9947 }
9948
9949
9950 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9951 PyObject *resultobj;
9952 wxFont *arg1 = (wxFont *) 0 ;
9953 wxFontEncoding result;
9954 PyObject * obj0 = 0 ;
9955 char *kwnames[] = {
9956 (char *) "self", NULL
9957 };
9958
9959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
9960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9961 if (SWIG_arg_fail(1)) SWIG_fail;
9962 {
9963 PyThreadState* __tstate = wxPyBeginAllowThreads();
9964 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
9965
9966 wxPyEndAllowThreads(__tstate);
9967 if (PyErr_Occurred()) SWIG_fail;
9968 }
9969 resultobj = SWIG_From_int((result));
9970 return resultobj;
9971 fail:
9972 return NULL;
9973 }
9974
9975
9976 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9977 PyObject *resultobj;
9978 wxFont *arg1 = (wxFont *) 0 ;
9979 wxNativeFontInfo *result;
9980 PyObject * obj0 = 0 ;
9981 char *kwnames[] = {
9982 (char *) "self", NULL
9983 };
9984
9985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
9986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9987 if (SWIG_arg_fail(1)) SWIG_fail;
9988 {
9989 PyThreadState* __tstate = wxPyBeginAllowThreads();
9990 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
9991
9992 wxPyEndAllowThreads(__tstate);
9993 if (PyErr_Occurred()) SWIG_fail;
9994 }
9995 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
9996 return resultobj;
9997 fail:
9998 return NULL;
9999 }
10000
10001
10002 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
10003 PyObject *resultobj;
10004 wxFont *arg1 = (wxFont *) 0 ;
10005 bool result;
10006 PyObject * obj0 = 0 ;
10007 char *kwnames[] = {
10008 (char *) "self", NULL
10009 };
10010
10011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
10012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10013 if (SWIG_arg_fail(1)) SWIG_fail;
10014 {
10015 PyThreadState* __tstate = wxPyBeginAllowThreads();
10016 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
10017
10018 wxPyEndAllowThreads(__tstate);
10019 if (PyErr_Occurred()) SWIG_fail;
10020 }
10021 {
10022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10023 }
10024 return resultobj;
10025 fail:
10026 return NULL;
10027 }
10028
10029
10030 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10031 PyObject *resultobj;
10032 wxFont *arg1 = (wxFont *) 0 ;
10033 wxString result;
10034 PyObject * obj0 = 0 ;
10035 char *kwnames[] = {
10036 (char *) "self", NULL
10037 };
10038
10039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
10040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10041 if (SWIG_arg_fail(1)) SWIG_fail;
10042 {
10043 PyThreadState* __tstate = wxPyBeginAllowThreads();
10044 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
10045
10046 wxPyEndAllowThreads(__tstate);
10047 if (PyErr_Occurred()) SWIG_fail;
10048 }
10049 {
10050 #if wxUSE_UNICODE
10051 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10052 #else
10053 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10054 #endif
10055 }
10056 return resultobj;
10057 fail:
10058 return NULL;
10059 }
10060
10061
10062 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10063 PyObject *resultobj;
10064 wxFont *arg1 = (wxFont *) 0 ;
10065 wxString result;
10066 PyObject * obj0 = 0 ;
10067 char *kwnames[] = {
10068 (char *) "self", NULL
10069 };
10070
10071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
10072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10073 if (SWIG_arg_fail(1)) SWIG_fail;
10074 {
10075 PyThreadState* __tstate = wxPyBeginAllowThreads();
10076 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
10077
10078 wxPyEndAllowThreads(__tstate);
10079 if (PyErr_Occurred()) SWIG_fail;
10080 }
10081 {
10082 #if wxUSE_UNICODE
10083 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10084 #else
10085 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10086 #endif
10087 }
10088 return resultobj;
10089 fail:
10090 return NULL;
10091 }
10092
10093
10094 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10095 PyObject *resultobj;
10096 wxFont *arg1 = (wxFont *) 0 ;
10097 int arg2 ;
10098 PyObject * obj0 = 0 ;
10099 PyObject * obj1 = 0 ;
10100 char *kwnames[] = {
10101 (char *) "self",(char *) "pointSize", NULL
10102 };
10103
10104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
10105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10106 if (SWIG_arg_fail(1)) SWIG_fail;
10107 {
10108 arg2 = (int)(SWIG_As_int(obj1));
10109 if (SWIG_arg_fail(2)) SWIG_fail;
10110 }
10111 {
10112 PyThreadState* __tstate = wxPyBeginAllowThreads();
10113 (arg1)->SetPointSize(arg2);
10114
10115 wxPyEndAllowThreads(__tstate);
10116 if (PyErr_Occurred()) SWIG_fail;
10117 }
10118 Py_INCREF(Py_None); resultobj = Py_None;
10119 return resultobj;
10120 fail:
10121 return NULL;
10122 }
10123
10124
10125 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10126 PyObject *resultobj;
10127 wxFont *arg1 = (wxFont *) 0 ;
10128 wxSize *arg2 = 0 ;
10129 wxSize temp2 ;
10130 PyObject * obj0 = 0 ;
10131 PyObject * obj1 = 0 ;
10132 char *kwnames[] = {
10133 (char *) "self",(char *) "pixelSize", NULL
10134 };
10135
10136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10138 if (SWIG_arg_fail(1)) SWIG_fail;
10139 {
10140 arg2 = &temp2;
10141 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10142 }
10143 {
10144 PyThreadState* __tstate = wxPyBeginAllowThreads();
10145 (arg1)->SetPixelSize((wxSize const &)*arg2);
10146
10147 wxPyEndAllowThreads(__tstate);
10148 if (PyErr_Occurred()) SWIG_fail;
10149 }
10150 Py_INCREF(Py_None); resultobj = Py_None;
10151 return resultobj;
10152 fail:
10153 return NULL;
10154 }
10155
10156
10157 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10158 PyObject *resultobj;
10159 wxFont *arg1 = (wxFont *) 0 ;
10160 int arg2 ;
10161 PyObject * obj0 = 0 ;
10162 PyObject * obj1 = 0 ;
10163 char *kwnames[] = {
10164 (char *) "self",(char *) "family", NULL
10165 };
10166
10167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10169 if (SWIG_arg_fail(1)) SWIG_fail;
10170 {
10171 arg2 = (int)(SWIG_As_int(obj1));
10172 if (SWIG_arg_fail(2)) SWIG_fail;
10173 }
10174 {
10175 PyThreadState* __tstate = wxPyBeginAllowThreads();
10176 (arg1)->SetFamily(arg2);
10177
10178 wxPyEndAllowThreads(__tstate);
10179 if (PyErr_Occurred()) SWIG_fail;
10180 }
10181 Py_INCREF(Py_None); resultobj = Py_None;
10182 return resultobj;
10183 fail:
10184 return NULL;
10185 }
10186
10187
10188 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10189 PyObject *resultobj;
10190 wxFont *arg1 = (wxFont *) 0 ;
10191 int arg2 ;
10192 PyObject * obj0 = 0 ;
10193 PyObject * obj1 = 0 ;
10194 char *kwnames[] = {
10195 (char *) "self",(char *) "style", NULL
10196 };
10197
10198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10200 if (SWIG_arg_fail(1)) SWIG_fail;
10201 {
10202 arg2 = (int)(SWIG_As_int(obj1));
10203 if (SWIG_arg_fail(2)) SWIG_fail;
10204 }
10205 {
10206 PyThreadState* __tstate = wxPyBeginAllowThreads();
10207 (arg1)->SetStyle(arg2);
10208
10209 wxPyEndAllowThreads(__tstate);
10210 if (PyErr_Occurred()) SWIG_fail;
10211 }
10212 Py_INCREF(Py_None); resultobj = Py_None;
10213 return resultobj;
10214 fail:
10215 return NULL;
10216 }
10217
10218
10219 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10220 PyObject *resultobj;
10221 wxFont *arg1 = (wxFont *) 0 ;
10222 int arg2 ;
10223 PyObject * obj0 = 0 ;
10224 PyObject * obj1 = 0 ;
10225 char *kwnames[] = {
10226 (char *) "self",(char *) "weight", NULL
10227 };
10228
10229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10231 if (SWIG_arg_fail(1)) SWIG_fail;
10232 {
10233 arg2 = (int)(SWIG_As_int(obj1));
10234 if (SWIG_arg_fail(2)) SWIG_fail;
10235 }
10236 {
10237 PyThreadState* __tstate = wxPyBeginAllowThreads();
10238 (arg1)->SetWeight(arg2);
10239
10240 wxPyEndAllowThreads(__tstate);
10241 if (PyErr_Occurred()) SWIG_fail;
10242 }
10243 Py_INCREF(Py_None); resultobj = Py_None;
10244 return resultobj;
10245 fail:
10246 return NULL;
10247 }
10248
10249
10250 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10251 PyObject *resultobj;
10252 wxFont *arg1 = (wxFont *) 0 ;
10253 wxString *arg2 = 0 ;
10254 bool temp2 = false ;
10255 PyObject * obj0 = 0 ;
10256 PyObject * obj1 = 0 ;
10257 char *kwnames[] = {
10258 (char *) "self",(char *) "faceName", NULL
10259 };
10260
10261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10263 if (SWIG_arg_fail(1)) SWIG_fail;
10264 {
10265 arg2 = wxString_in_helper(obj1);
10266 if (arg2 == NULL) SWIG_fail;
10267 temp2 = true;
10268 }
10269 {
10270 PyThreadState* __tstate = wxPyBeginAllowThreads();
10271 (arg1)->SetFaceName((wxString const &)*arg2);
10272
10273 wxPyEndAllowThreads(__tstate);
10274 if (PyErr_Occurred()) SWIG_fail;
10275 }
10276 Py_INCREF(Py_None); resultobj = Py_None;
10277 {
10278 if (temp2)
10279 delete arg2;
10280 }
10281 return resultobj;
10282 fail:
10283 {
10284 if (temp2)
10285 delete arg2;
10286 }
10287 return NULL;
10288 }
10289
10290
10291 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10292 PyObject *resultobj;
10293 wxFont *arg1 = (wxFont *) 0 ;
10294 bool arg2 ;
10295 PyObject * obj0 = 0 ;
10296 PyObject * obj1 = 0 ;
10297 char *kwnames[] = {
10298 (char *) "self",(char *) "underlined", NULL
10299 };
10300
10301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10303 if (SWIG_arg_fail(1)) SWIG_fail;
10304 {
10305 arg2 = (bool)(SWIG_As_bool(obj1));
10306 if (SWIG_arg_fail(2)) SWIG_fail;
10307 }
10308 {
10309 PyThreadState* __tstate = wxPyBeginAllowThreads();
10310 (arg1)->SetUnderlined(arg2);
10311
10312 wxPyEndAllowThreads(__tstate);
10313 if (PyErr_Occurred()) SWIG_fail;
10314 }
10315 Py_INCREF(Py_None); resultobj = Py_None;
10316 return resultobj;
10317 fail:
10318 return NULL;
10319 }
10320
10321
10322 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10323 PyObject *resultobj;
10324 wxFont *arg1 = (wxFont *) 0 ;
10325 wxFontEncoding arg2 ;
10326 PyObject * obj0 = 0 ;
10327 PyObject * obj1 = 0 ;
10328 char *kwnames[] = {
10329 (char *) "self",(char *) "encoding", NULL
10330 };
10331
10332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10334 if (SWIG_arg_fail(1)) SWIG_fail;
10335 {
10336 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10337 if (SWIG_arg_fail(2)) SWIG_fail;
10338 }
10339 {
10340 PyThreadState* __tstate = wxPyBeginAllowThreads();
10341 (arg1)->SetEncoding((wxFontEncoding )arg2);
10342
10343 wxPyEndAllowThreads(__tstate);
10344 if (PyErr_Occurred()) SWIG_fail;
10345 }
10346 Py_INCREF(Py_None); resultobj = Py_None;
10347 return resultobj;
10348 fail:
10349 return NULL;
10350 }
10351
10352
10353 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10354 PyObject *resultobj;
10355 wxFont *arg1 = (wxFont *) 0 ;
10356 wxNativeFontInfo *arg2 = 0 ;
10357 PyObject * obj0 = 0 ;
10358 PyObject * obj1 = 0 ;
10359 char *kwnames[] = {
10360 (char *) "self",(char *) "info", NULL
10361 };
10362
10363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10365 if (SWIG_arg_fail(1)) SWIG_fail;
10366 {
10367 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10368 if (SWIG_arg_fail(2)) SWIG_fail;
10369 if (arg2 == NULL) {
10370 SWIG_null_ref("wxNativeFontInfo");
10371 }
10372 if (SWIG_arg_fail(2)) SWIG_fail;
10373 }
10374 {
10375 PyThreadState* __tstate = wxPyBeginAllowThreads();
10376 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10377
10378 wxPyEndAllowThreads(__tstate);
10379 if (PyErr_Occurred()) SWIG_fail;
10380 }
10381 Py_INCREF(Py_None); resultobj = Py_None;
10382 return resultobj;
10383 fail:
10384 return NULL;
10385 }
10386
10387
10388 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10389 PyObject *resultobj;
10390 wxFont *arg1 = (wxFont *) 0 ;
10391 wxString *arg2 = 0 ;
10392 bool temp2 = false ;
10393 PyObject * obj0 = 0 ;
10394 PyObject * obj1 = 0 ;
10395 char *kwnames[] = {
10396 (char *) "self",(char *) "info", NULL
10397 };
10398
10399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10401 if (SWIG_arg_fail(1)) SWIG_fail;
10402 {
10403 arg2 = wxString_in_helper(obj1);
10404 if (arg2 == NULL) SWIG_fail;
10405 temp2 = true;
10406 }
10407 {
10408 PyThreadState* __tstate = wxPyBeginAllowThreads();
10409 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10410
10411 wxPyEndAllowThreads(__tstate);
10412 if (PyErr_Occurred()) SWIG_fail;
10413 }
10414 Py_INCREF(Py_None); resultobj = Py_None;
10415 {
10416 if (temp2)
10417 delete arg2;
10418 }
10419 return resultobj;
10420 fail:
10421 {
10422 if (temp2)
10423 delete arg2;
10424 }
10425 return NULL;
10426 }
10427
10428
10429 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10430 PyObject *resultobj;
10431 wxFont *arg1 = (wxFont *) 0 ;
10432 wxString *arg2 = 0 ;
10433 bool temp2 = false ;
10434 PyObject * obj0 = 0 ;
10435 PyObject * obj1 = 0 ;
10436 char *kwnames[] = {
10437 (char *) "self",(char *) "info", NULL
10438 };
10439
10440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10442 if (SWIG_arg_fail(1)) SWIG_fail;
10443 {
10444 arg2 = wxString_in_helper(obj1);
10445 if (arg2 == NULL) SWIG_fail;
10446 temp2 = true;
10447 }
10448 {
10449 PyThreadState* __tstate = wxPyBeginAllowThreads();
10450 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
10451
10452 wxPyEndAllowThreads(__tstate);
10453 if (PyErr_Occurred()) SWIG_fail;
10454 }
10455 Py_INCREF(Py_None); resultobj = Py_None;
10456 {
10457 if (temp2)
10458 delete arg2;
10459 }
10460 return resultobj;
10461 fail:
10462 {
10463 if (temp2)
10464 delete arg2;
10465 }
10466 return NULL;
10467 }
10468
10469
10470 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
10471 PyObject *resultobj;
10472 wxFont *arg1 = (wxFont *) 0 ;
10473 wxString result;
10474 PyObject * obj0 = 0 ;
10475 char *kwnames[] = {
10476 (char *) "self", NULL
10477 };
10478
10479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
10480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10481 if (SWIG_arg_fail(1)) SWIG_fail;
10482 {
10483 PyThreadState* __tstate = wxPyBeginAllowThreads();
10484 result = ((wxFont const *)arg1)->GetFamilyString();
10485
10486 wxPyEndAllowThreads(__tstate);
10487 if (PyErr_Occurred()) SWIG_fail;
10488 }
10489 {
10490 #if wxUSE_UNICODE
10491 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10492 #else
10493 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10494 #endif
10495 }
10496 return resultobj;
10497 fail:
10498 return NULL;
10499 }
10500
10501
10502 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
10503 PyObject *resultobj;
10504 wxFont *arg1 = (wxFont *) 0 ;
10505 wxString result;
10506 PyObject * obj0 = 0 ;
10507 char *kwnames[] = {
10508 (char *) "self", NULL
10509 };
10510
10511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
10512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10513 if (SWIG_arg_fail(1)) SWIG_fail;
10514 {
10515 PyThreadState* __tstate = wxPyBeginAllowThreads();
10516 result = ((wxFont const *)arg1)->GetStyleString();
10517
10518 wxPyEndAllowThreads(__tstate);
10519 if (PyErr_Occurred()) SWIG_fail;
10520 }
10521 {
10522 #if wxUSE_UNICODE
10523 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10524 #else
10525 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10526 #endif
10527 }
10528 return resultobj;
10529 fail:
10530 return NULL;
10531 }
10532
10533
10534 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
10535 PyObject *resultobj;
10536 wxFont *arg1 = (wxFont *) 0 ;
10537 wxString result;
10538 PyObject * obj0 = 0 ;
10539 char *kwnames[] = {
10540 (char *) "self", NULL
10541 };
10542
10543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
10544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10545 if (SWIG_arg_fail(1)) SWIG_fail;
10546 {
10547 PyThreadState* __tstate = wxPyBeginAllowThreads();
10548 result = ((wxFont const *)arg1)->GetWeightString();
10549
10550 wxPyEndAllowThreads(__tstate);
10551 if (PyErr_Occurred()) SWIG_fail;
10552 }
10553 {
10554 #if wxUSE_UNICODE
10555 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10556 #else
10557 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10558 #endif
10559 }
10560 return resultobj;
10561 fail:
10562 return NULL;
10563 }
10564
10565
10566 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10567 PyObject *resultobj;
10568 wxFont *arg1 = (wxFont *) 0 ;
10569 bool arg2 = (bool) true ;
10570 PyObject * obj0 = 0 ;
10571 PyObject * obj1 = 0 ;
10572 char *kwnames[] = {
10573 (char *) "self",(char *) "no", NULL
10574 };
10575
10576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
10577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10578 if (SWIG_arg_fail(1)) SWIG_fail;
10579 if (obj1) {
10580 {
10581 arg2 = (bool)(SWIG_As_bool(obj1));
10582 if (SWIG_arg_fail(2)) SWIG_fail;
10583 }
10584 }
10585 {
10586 PyThreadState* __tstate = wxPyBeginAllowThreads();
10587 (arg1)->SetNoAntiAliasing(arg2);
10588
10589 wxPyEndAllowThreads(__tstate);
10590 if (PyErr_Occurred()) SWIG_fail;
10591 }
10592 Py_INCREF(Py_None); resultobj = Py_None;
10593 return resultobj;
10594 fail:
10595 return NULL;
10596 }
10597
10598
10599 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10600 PyObject *resultobj;
10601 wxFont *arg1 = (wxFont *) 0 ;
10602 bool result;
10603 PyObject * obj0 = 0 ;
10604 char *kwnames[] = {
10605 (char *) "self", NULL
10606 };
10607
10608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
10609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10610 if (SWIG_arg_fail(1)) SWIG_fail;
10611 {
10612 PyThreadState* __tstate = wxPyBeginAllowThreads();
10613 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
10614
10615 wxPyEndAllowThreads(__tstate);
10616 if (PyErr_Occurred()) SWIG_fail;
10617 }
10618 {
10619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10620 }
10621 return resultobj;
10622 fail:
10623 return NULL;
10624 }
10625
10626
10627 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10628 PyObject *resultobj;
10629 wxFontEncoding result;
10630 char *kwnames[] = {
10631 NULL
10632 };
10633
10634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
10635 {
10636 if (!wxPyCheckForApp()) SWIG_fail;
10637 PyThreadState* __tstate = wxPyBeginAllowThreads();
10638 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
10639
10640 wxPyEndAllowThreads(__tstate);
10641 if (PyErr_Occurred()) SWIG_fail;
10642 }
10643 resultobj = SWIG_From_int((result));
10644 return resultobj;
10645 fail:
10646 return NULL;
10647 }
10648
10649
10650 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10651 PyObject *resultobj;
10652 wxFontEncoding arg1 ;
10653 PyObject * obj0 = 0 ;
10654 char *kwnames[] = {
10655 (char *) "encoding", NULL
10656 };
10657
10658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
10659 {
10660 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
10661 if (SWIG_arg_fail(1)) SWIG_fail;
10662 }
10663 {
10664 if (!wxPyCheckForApp()) SWIG_fail;
10665 PyThreadState* __tstate = wxPyBeginAllowThreads();
10666 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
10667
10668 wxPyEndAllowThreads(__tstate);
10669 if (PyErr_Occurred()) SWIG_fail;
10670 }
10671 Py_INCREF(Py_None); resultobj = Py_None;
10672 return resultobj;
10673 fail:
10674 return NULL;
10675 }
10676
10677
10678 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
10679 PyObject *obj;
10680 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10681 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
10682 Py_INCREF(obj);
10683 return Py_BuildValue((char *)"");
10684 }
10685 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10686 PyObject *resultobj;
10687 wxPyFontEnumerator *result;
10688 char *kwnames[] = {
10689 NULL
10690 };
10691
10692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
10693 {
10694 if (!wxPyCheckForApp()) SWIG_fail;
10695 PyThreadState* __tstate = wxPyBeginAllowThreads();
10696 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
10697
10698 wxPyEndAllowThreads(__tstate);
10699 if (PyErr_Occurred()) SWIG_fail;
10700 }
10701 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
10702 return resultobj;
10703 fail:
10704 return NULL;
10705 }
10706
10707
10708 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10709 PyObject *resultobj;
10710 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10711 PyObject * obj0 = 0 ;
10712 char *kwnames[] = {
10713 (char *) "self", NULL
10714 };
10715
10716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
10717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10718 if (SWIG_arg_fail(1)) SWIG_fail;
10719 {
10720 PyThreadState* __tstate = wxPyBeginAllowThreads();
10721 delete arg1;
10722
10723 wxPyEndAllowThreads(__tstate);
10724 if (PyErr_Occurred()) SWIG_fail;
10725 }
10726 Py_INCREF(Py_None); resultobj = Py_None;
10727 return resultobj;
10728 fail:
10729 return NULL;
10730 }
10731
10732
10733 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10734 PyObject *resultobj;
10735 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10736 PyObject *arg2 = (PyObject *) 0 ;
10737 PyObject *arg3 = (PyObject *) 0 ;
10738 bool arg4 ;
10739 PyObject * obj0 = 0 ;
10740 PyObject * obj1 = 0 ;
10741 PyObject * obj2 = 0 ;
10742 PyObject * obj3 = 0 ;
10743 char *kwnames[] = {
10744 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10745 };
10746
10747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10749 if (SWIG_arg_fail(1)) SWIG_fail;
10750 arg2 = obj1;
10751 arg3 = obj2;
10752 {
10753 arg4 = (bool)(SWIG_As_bool(obj3));
10754 if (SWIG_arg_fail(4)) SWIG_fail;
10755 }
10756 {
10757 PyThreadState* __tstate = wxPyBeginAllowThreads();
10758 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10759
10760 wxPyEndAllowThreads(__tstate);
10761 if (PyErr_Occurred()) SWIG_fail;
10762 }
10763 Py_INCREF(Py_None); resultobj = Py_None;
10764 return resultobj;
10765 fail:
10766 return NULL;
10767 }
10768
10769
10770 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10771 PyObject *resultobj;
10772 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10773 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
10774 bool arg3 = (bool) false ;
10775 bool result;
10776 PyObject * obj0 = 0 ;
10777 PyObject * obj1 = 0 ;
10778 PyObject * obj2 = 0 ;
10779 char *kwnames[] = {
10780 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
10781 };
10782
10783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
10784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10785 if (SWIG_arg_fail(1)) SWIG_fail;
10786 if (obj1) {
10787 {
10788 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10789 if (SWIG_arg_fail(2)) SWIG_fail;
10790 }
10791 }
10792 if (obj2) {
10793 {
10794 arg3 = (bool)(SWIG_As_bool(obj2));
10795 if (SWIG_arg_fail(3)) SWIG_fail;
10796 }
10797 }
10798 {
10799 PyThreadState* __tstate = wxPyBeginAllowThreads();
10800 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
10801
10802 wxPyEndAllowThreads(__tstate);
10803 if (PyErr_Occurred()) SWIG_fail;
10804 }
10805 {
10806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10807 }
10808 return resultobj;
10809 fail:
10810 return NULL;
10811 }
10812
10813
10814 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10815 PyObject *resultobj;
10816 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10817 wxString const &arg2_defvalue = wxPyEmptyString ;
10818 wxString *arg2 = (wxString *) &arg2_defvalue ;
10819 bool result;
10820 bool temp2 = false ;
10821 PyObject * obj0 = 0 ;
10822 PyObject * obj1 = 0 ;
10823 char *kwnames[] = {
10824 (char *) "self",(char *) "facename", NULL
10825 };
10826
10827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
10828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10829 if (SWIG_arg_fail(1)) SWIG_fail;
10830 if (obj1) {
10831 {
10832 arg2 = wxString_in_helper(obj1);
10833 if (arg2 == NULL) SWIG_fail;
10834 temp2 = true;
10835 }
10836 }
10837 {
10838 PyThreadState* __tstate = wxPyBeginAllowThreads();
10839 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
10840
10841 wxPyEndAllowThreads(__tstate);
10842 if (PyErr_Occurred()) SWIG_fail;
10843 }
10844 {
10845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10846 }
10847 {
10848 if (temp2)
10849 delete arg2;
10850 }
10851 return resultobj;
10852 fail:
10853 {
10854 if (temp2)
10855 delete arg2;
10856 }
10857 return NULL;
10858 }
10859
10860
10861 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10862 PyObject *resultobj;
10863 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10864 PyObject *result;
10865 PyObject * obj0 = 0 ;
10866 char *kwnames[] = {
10867 (char *) "self", NULL
10868 };
10869
10870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
10871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10872 if (SWIG_arg_fail(1)) SWIG_fail;
10873 {
10874 PyThreadState* __tstate = wxPyBeginAllowThreads();
10875 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
10876
10877 wxPyEndAllowThreads(__tstate);
10878 if (PyErr_Occurred()) SWIG_fail;
10879 }
10880 resultobj = result;
10881 return resultobj;
10882 fail:
10883 return NULL;
10884 }
10885
10886
10887 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10888 PyObject *resultobj;
10889 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10890 PyObject *result;
10891 PyObject * obj0 = 0 ;
10892 char *kwnames[] = {
10893 (char *) "self", NULL
10894 };
10895
10896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
10897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10898 if (SWIG_arg_fail(1)) SWIG_fail;
10899 {
10900 PyThreadState* __tstate = wxPyBeginAllowThreads();
10901 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
10902
10903 wxPyEndAllowThreads(__tstate);
10904 if (PyErr_Occurred()) SWIG_fail;
10905 }
10906 resultobj = result;
10907 return resultobj;
10908 fail:
10909 return NULL;
10910 }
10911
10912
10913 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
10914 PyObject *obj;
10915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10916 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
10917 Py_INCREF(obj);
10918 return Py_BuildValue((char *)"");
10919 }
10920 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
10921 PyObject *resultobj;
10922 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10923 int arg2 ;
10924 PyObject * obj0 = 0 ;
10925 PyObject * obj1 = 0 ;
10926 char *kwnames[] = {
10927 (char *) "self",(char *) "Language", NULL
10928 };
10929
10930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) 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 {
10934 arg2 = (int)(SWIG_As_int(obj1));
10935 if (SWIG_arg_fail(2)) SWIG_fail;
10936 }
10937 if (arg1) (arg1)->Language = arg2;
10938
10939 Py_INCREF(Py_None); resultobj = Py_None;
10940 return resultobj;
10941 fail:
10942 return NULL;
10943 }
10944
10945
10946 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
10947 PyObject *resultobj;
10948 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10949 int result;
10950 PyObject * obj0 = 0 ;
10951 char *kwnames[] = {
10952 (char *) "self", NULL
10953 };
10954
10955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) 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 result = (int) ((arg1)->Language);
10959
10960 {
10961 resultobj = SWIG_From_int((int)(result));
10962 }
10963 return resultobj;
10964 fail:
10965 return NULL;
10966 }
10967
10968
10969 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
10970 PyObject *resultobj;
10971 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10972 wxString *arg2 = (wxString *) 0 ;
10973 bool temp2 = false ;
10974 PyObject * obj0 = 0 ;
10975 PyObject * obj1 = 0 ;
10976 char *kwnames[] = {
10977 (char *) "self",(char *) "CanonicalName", NULL
10978 };
10979
10980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
10981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10982 if (SWIG_arg_fail(1)) SWIG_fail;
10983 {
10984 arg2 = wxString_in_helper(obj1);
10985 if (arg2 == NULL) SWIG_fail;
10986 temp2 = true;
10987 }
10988 if (arg1) (arg1)->CanonicalName = *arg2;
10989
10990 Py_INCREF(Py_None); resultobj = Py_None;
10991 {
10992 if (temp2)
10993 delete arg2;
10994 }
10995 return resultobj;
10996 fail:
10997 {
10998 if (temp2)
10999 delete arg2;
11000 }
11001 return NULL;
11002 }
11003
11004
11005 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
11006 PyObject *resultobj;
11007 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11008 wxString *result;
11009 PyObject * obj0 = 0 ;
11010 char *kwnames[] = {
11011 (char *) "self", NULL
11012 };
11013
11014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
11015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11016 if (SWIG_arg_fail(1)) SWIG_fail;
11017 result = (wxString *)& ((arg1)->CanonicalName);
11018
11019 {
11020 #if wxUSE_UNICODE
11021 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11022 #else
11023 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11024 #endif
11025 }
11026 return resultobj;
11027 fail:
11028 return NULL;
11029 }
11030
11031
11032 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
11033 PyObject *resultobj;
11034 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11035 wxString *arg2 = (wxString *) 0 ;
11036 bool temp2 = false ;
11037 PyObject * obj0 = 0 ;
11038 PyObject * obj1 = 0 ;
11039 char *kwnames[] = {
11040 (char *) "self",(char *) "Description", NULL
11041 };
11042
11043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
11044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11045 if (SWIG_arg_fail(1)) SWIG_fail;
11046 {
11047 arg2 = wxString_in_helper(obj1);
11048 if (arg2 == NULL) SWIG_fail;
11049 temp2 = true;
11050 }
11051 if (arg1) (arg1)->Description = *arg2;
11052
11053 Py_INCREF(Py_None); resultobj = Py_None;
11054 {
11055 if (temp2)
11056 delete arg2;
11057 }
11058 return resultobj;
11059 fail:
11060 {
11061 if (temp2)
11062 delete arg2;
11063 }
11064 return NULL;
11065 }
11066
11067
11068 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
11069 PyObject *resultobj;
11070 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11071 wxString *result;
11072 PyObject * obj0 = 0 ;
11073 char *kwnames[] = {
11074 (char *) "self", NULL
11075 };
11076
11077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
11078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11079 if (SWIG_arg_fail(1)) SWIG_fail;
11080 result = (wxString *)& ((arg1)->Description);
11081
11082 {
11083 #if wxUSE_UNICODE
11084 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11085 #else
11086 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11087 #endif
11088 }
11089 return resultobj;
11090 fail:
11091 return NULL;
11092 }
11093
11094
11095 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
11096 PyObject *obj;
11097 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11098 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
11099 Py_INCREF(obj);
11100 return Py_BuildValue((char *)"");
11101 }
11102 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11103 PyObject *resultobj;
11104 int arg1 = (int) -1 ;
11105 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11106 wxLocale *result;
11107 PyObject * obj0 = 0 ;
11108 PyObject * obj1 = 0 ;
11109 char *kwnames[] = {
11110 (char *) "language",(char *) "flags", NULL
11111 };
11112
11113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
11114 if (obj0) {
11115 {
11116 arg1 = (int)(SWIG_As_int(obj0));
11117 if (SWIG_arg_fail(1)) SWIG_fail;
11118 }
11119 }
11120 if (obj1) {
11121 {
11122 arg2 = (int)(SWIG_As_int(obj1));
11123 if (SWIG_arg_fail(2)) SWIG_fail;
11124 }
11125 }
11126 {
11127 PyThreadState* __tstate = wxPyBeginAllowThreads();
11128 result = (wxLocale *)new_wxLocale(arg1,arg2);
11129
11130 wxPyEndAllowThreads(__tstate);
11131 if (PyErr_Occurred()) SWIG_fail;
11132 }
11133 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11134 return resultobj;
11135 fail:
11136 return NULL;
11137 }
11138
11139
11140 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11141 PyObject *resultobj;
11142 wxLocale *arg1 = (wxLocale *) 0 ;
11143 PyObject * obj0 = 0 ;
11144 char *kwnames[] = {
11145 (char *) "self", NULL
11146 };
11147
11148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11150 if (SWIG_arg_fail(1)) SWIG_fail;
11151 {
11152 PyThreadState* __tstate = wxPyBeginAllowThreads();
11153 delete arg1;
11154
11155 wxPyEndAllowThreads(__tstate);
11156 if (PyErr_Occurred()) SWIG_fail;
11157 }
11158 Py_INCREF(Py_None); resultobj = Py_None;
11159 return resultobj;
11160 fail:
11161 return NULL;
11162 }
11163
11164
11165 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11166 PyObject *resultobj;
11167 wxLocale *arg1 = (wxLocale *) 0 ;
11168 wxString *arg2 = 0 ;
11169 wxString const &arg3_defvalue = wxPyEmptyString ;
11170 wxString *arg3 = (wxString *) &arg3_defvalue ;
11171 wxString const &arg4_defvalue = wxPyEmptyString ;
11172 wxString *arg4 = (wxString *) &arg4_defvalue ;
11173 bool arg5 = (bool) true ;
11174 bool arg6 = (bool) false ;
11175 bool result;
11176 bool temp2 = false ;
11177 bool temp3 = false ;
11178 bool temp4 = false ;
11179 PyObject * obj0 = 0 ;
11180 PyObject * obj1 = 0 ;
11181 PyObject * obj2 = 0 ;
11182 PyObject * obj3 = 0 ;
11183 PyObject * obj4 = 0 ;
11184 PyObject * obj5 = 0 ;
11185 char *kwnames[] = {
11186 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11187 };
11188
11189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11191 if (SWIG_arg_fail(1)) SWIG_fail;
11192 {
11193 arg2 = wxString_in_helper(obj1);
11194 if (arg2 == NULL) SWIG_fail;
11195 temp2 = true;
11196 }
11197 if (obj2) {
11198 {
11199 arg3 = wxString_in_helper(obj2);
11200 if (arg3 == NULL) SWIG_fail;
11201 temp3 = true;
11202 }
11203 }
11204 if (obj3) {
11205 {
11206 arg4 = wxString_in_helper(obj3);
11207 if (arg4 == NULL) SWIG_fail;
11208 temp4 = true;
11209 }
11210 }
11211 if (obj4) {
11212 {
11213 arg5 = (bool)(SWIG_As_bool(obj4));
11214 if (SWIG_arg_fail(5)) SWIG_fail;
11215 }
11216 }
11217 if (obj5) {
11218 {
11219 arg6 = (bool)(SWIG_As_bool(obj5));
11220 if (SWIG_arg_fail(6)) SWIG_fail;
11221 }
11222 }
11223 {
11224 PyThreadState* __tstate = wxPyBeginAllowThreads();
11225 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11226
11227 wxPyEndAllowThreads(__tstate);
11228 if (PyErr_Occurred()) SWIG_fail;
11229 }
11230 {
11231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11232 }
11233 {
11234 if (temp2)
11235 delete arg2;
11236 }
11237 {
11238 if (temp3)
11239 delete arg3;
11240 }
11241 {
11242 if (temp4)
11243 delete arg4;
11244 }
11245 return resultobj;
11246 fail:
11247 {
11248 if (temp2)
11249 delete arg2;
11250 }
11251 {
11252 if (temp3)
11253 delete arg3;
11254 }
11255 {
11256 if (temp4)
11257 delete arg4;
11258 }
11259 return NULL;
11260 }
11261
11262
11263 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11264 PyObject *resultobj;
11265 wxLocale *arg1 = (wxLocale *) 0 ;
11266 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11267 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11268 bool result;
11269 PyObject * obj0 = 0 ;
11270 PyObject * obj1 = 0 ;
11271 PyObject * obj2 = 0 ;
11272 char *kwnames[] = {
11273 (char *) "self",(char *) "language",(char *) "flags", NULL
11274 };
11275
11276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11278 if (SWIG_arg_fail(1)) SWIG_fail;
11279 if (obj1) {
11280 {
11281 arg2 = (int)(SWIG_As_int(obj1));
11282 if (SWIG_arg_fail(2)) SWIG_fail;
11283 }
11284 }
11285 if (obj2) {
11286 {
11287 arg3 = (int)(SWIG_As_int(obj2));
11288 if (SWIG_arg_fail(3)) SWIG_fail;
11289 }
11290 }
11291 {
11292 PyThreadState* __tstate = wxPyBeginAllowThreads();
11293 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11294
11295 wxPyEndAllowThreads(__tstate);
11296 if (PyErr_Occurred()) SWIG_fail;
11297 }
11298 {
11299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11300 }
11301 return resultobj;
11302 fail:
11303 return NULL;
11304 }
11305
11306
11307 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11308 PyObject *resultobj;
11309 int result;
11310 char *kwnames[] = {
11311 NULL
11312 };
11313
11314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11315 {
11316 PyThreadState* __tstate = wxPyBeginAllowThreads();
11317 result = (int)wxLocale::GetSystemLanguage();
11318
11319 wxPyEndAllowThreads(__tstate);
11320 if (PyErr_Occurred()) SWIG_fail;
11321 }
11322 {
11323 resultobj = SWIG_From_int((int)(result));
11324 }
11325 return resultobj;
11326 fail:
11327 return NULL;
11328 }
11329
11330
11331 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11332 PyObject *resultobj;
11333 wxFontEncoding result;
11334 char *kwnames[] = {
11335 NULL
11336 };
11337
11338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11339 {
11340 PyThreadState* __tstate = wxPyBeginAllowThreads();
11341 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11342
11343 wxPyEndAllowThreads(__tstate);
11344 if (PyErr_Occurred()) SWIG_fail;
11345 }
11346 resultobj = SWIG_From_int((result));
11347 return resultobj;
11348 fail:
11349 return NULL;
11350 }
11351
11352
11353 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11354 PyObject *resultobj;
11355 wxString result;
11356 char *kwnames[] = {
11357 NULL
11358 };
11359
11360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11361 {
11362 PyThreadState* __tstate = wxPyBeginAllowThreads();
11363 result = wxLocale::GetSystemEncodingName();
11364
11365 wxPyEndAllowThreads(__tstate);
11366 if (PyErr_Occurred()) SWIG_fail;
11367 }
11368 {
11369 #if wxUSE_UNICODE
11370 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11371 #else
11372 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11373 #endif
11374 }
11375 return resultobj;
11376 fail:
11377 return NULL;
11378 }
11379
11380
11381 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11382 PyObject *resultobj;
11383 wxLocale *arg1 = (wxLocale *) 0 ;
11384 bool result;
11385 PyObject * obj0 = 0 ;
11386 char *kwnames[] = {
11387 (char *) "self", NULL
11388 };
11389
11390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11392 if (SWIG_arg_fail(1)) SWIG_fail;
11393 {
11394 PyThreadState* __tstate = wxPyBeginAllowThreads();
11395 result = (bool)((wxLocale const *)arg1)->IsOk();
11396
11397 wxPyEndAllowThreads(__tstate);
11398 if (PyErr_Occurred()) SWIG_fail;
11399 }
11400 {
11401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11402 }
11403 return resultobj;
11404 fail:
11405 return NULL;
11406 }
11407
11408
11409 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11410 PyObject *resultobj;
11411 wxLocale *arg1 = (wxLocale *) 0 ;
11412 wxString result;
11413 PyObject * obj0 = 0 ;
11414 char *kwnames[] = {
11415 (char *) "self", NULL
11416 };
11417
11418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11420 if (SWIG_arg_fail(1)) SWIG_fail;
11421 {
11422 PyThreadState* __tstate = wxPyBeginAllowThreads();
11423 result = ((wxLocale const *)arg1)->GetLocale();
11424
11425 wxPyEndAllowThreads(__tstate);
11426 if (PyErr_Occurred()) SWIG_fail;
11427 }
11428 {
11429 #if wxUSE_UNICODE
11430 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11431 #else
11432 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11433 #endif
11434 }
11435 return resultobj;
11436 fail:
11437 return NULL;
11438 }
11439
11440
11441 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11442 PyObject *resultobj;
11443 wxLocale *arg1 = (wxLocale *) 0 ;
11444 int result;
11445 PyObject * obj0 = 0 ;
11446 char *kwnames[] = {
11447 (char *) "self", NULL
11448 };
11449
11450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
11451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11452 if (SWIG_arg_fail(1)) SWIG_fail;
11453 {
11454 PyThreadState* __tstate = wxPyBeginAllowThreads();
11455 result = (int)((wxLocale const *)arg1)->GetLanguage();
11456
11457 wxPyEndAllowThreads(__tstate);
11458 if (PyErr_Occurred()) SWIG_fail;
11459 }
11460 {
11461 resultobj = SWIG_From_int((int)(result));
11462 }
11463 return resultobj;
11464 fail:
11465 return NULL;
11466 }
11467
11468
11469 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
11470 PyObject *resultobj;
11471 wxLocale *arg1 = (wxLocale *) 0 ;
11472 wxString result;
11473 PyObject * obj0 = 0 ;
11474 char *kwnames[] = {
11475 (char *) "self", NULL
11476 };
11477
11478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
11479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11480 if (SWIG_arg_fail(1)) SWIG_fail;
11481 {
11482 PyThreadState* __tstate = wxPyBeginAllowThreads();
11483 result = ((wxLocale const *)arg1)->GetSysName();
11484
11485 wxPyEndAllowThreads(__tstate);
11486 if (PyErr_Occurred()) SWIG_fail;
11487 }
11488 {
11489 #if wxUSE_UNICODE
11490 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11491 #else
11492 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11493 #endif
11494 }
11495 return resultobj;
11496 fail:
11497 return NULL;
11498 }
11499
11500
11501 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
11502 PyObject *resultobj;
11503 wxLocale *arg1 = (wxLocale *) 0 ;
11504 wxString result;
11505 PyObject * obj0 = 0 ;
11506 char *kwnames[] = {
11507 (char *) "self", NULL
11508 };
11509
11510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
11511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11512 if (SWIG_arg_fail(1)) SWIG_fail;
11513 {
11514 PyThreadState* __tstate = wxPyBeginAllowThreads();
11515 result = ((wxLocale const *)arg1)->GetCanonicalName();
11516
11517 wxPyEndAllowThreads(__tstate);
11518 if (PyErr_Occurred()) SWIG_fail;
11519 }
11520 {
11521 #if wxUSE_UNICODE
11522 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11523 #else
11524 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11525 #endif
11526 }
11527 return resultobj;
11528 fail:
11529 return NULL;
11530 }
11531
11532
11533 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
11534 PyObject *resultobj;
11535 wxString *arg1 = 0 ;
11536 bool temp1 = false ;
11537 PyObject * obj0 = 0 ;
11538 char *kwnames[] = {
11539 (char *) "prefix", NULL
11540 };
11541
11542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
11543 {
11544 arg1 = wxString_in_helper(obj0);
11545 if (arg1 == NULL) SWIG_fail;
11546 temp1 = true;
11547 }
11548 {
11549 PyThreadState* __tstate = wxPyBeginAllowThreads();
11550 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
11551
11552 wxPyEndAllowThreads(__tstate);
11553 if (PyErr_Occurred()) SWIG_fail;
11554 }
11555 Py_INCREF(Py_None); resultobj = Py_None;
11556 {
11557 if (temp1)
11558 delete arg1;
11559 }
11560 return resultobj;
11561 fail:
11562 {
11563 if (temp1)
11564 delete arg1;
11565 }
11566 return NULL;
11567 }
11568
11569
11570 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
11571 PyObject *resultobj;
11572 wxLocale *arg1 = (wxLocale *) 0 ;
11573 wxString *arg2 = 0 ;
11574 bool result;
11575 bool temp2 = false ;
11576 PyObject * obj0 = 0 ;
11577 PyObject * obj1 = 0 ;
11578 char *kwnames[] = {
11579 (char *) "self",(char *) "szDomain", NULL
11580 };
11581
11582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
11583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11584 if (SWIG_arg_fail(1)) SWIG_fail;
11585 {
11586 arg2 = wxString_in_helper(obj1);
11587 if (arg2 == NULL) SWIG_fail;
11588 temp2 = true;
11589 }
11590 {
11591 PyThreadState* __tstate = wxPyBeginAllowThreads();
11592 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
11593
11594 wxPyEndAllowThreads(__tstate);
11595 if (PyErr_Occurred()) SWIG_fail;
11596 }
11597 {
11598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11599 }
11600 {
11601 if (temp2)
11602 delete arg2;
11603 }
11604 return resultobj;
11605 fail:
11606 {
11607 if (temp2)
11608 delete arg2;
11609 }
11610 return NULL;
11611 }
11612
11613
11614 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
11615 PyObject *resultobj;
11616 wxLocale *arg1 = (wxLocale *) 0 ;
11617 wxString *arg2 = 0 ;
11618 bool result;
11619 bool temp2 = false ;
11620 PyObject * obj0 = 0 ;
11621 PyObject * obj1 = 0 ;
11622 char *kwnames[] = {
11623 (char *) "self",(char *) "szDomain", NULL
11624 };
11625
11626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
11627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11628 if (SWIG_arg_fail(1)) SWIG_fail;
11629 {
11630 arg2 = wxString_in_helper(obj1);
11631 if (arg2 == NULL) SWIG_fail;
11632 temp2 = true;
11633 }
11634 {
11635 PyThreadState* __tstate = wxPyBeginAllowThreads();
11636 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
11637
11638 wxPyEndAllowThreads(__tstate);
11639 if (PyErr_Occurred()) SWIG_fail;
11640 }
11641 {
11642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11643 }
11644 {
11645 if (temp2)
11646 delete arg2;
11647 }
11648 return resultobj;
11649 fail:
11650 {
11651 if (temp2)
11652 delete arg2;
11653 }
11654 return NULL;
11655 }
11656
11657
11658 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11659 PyObject *resultobj;
11660 int arg1 ;
11661 wxLanguageInfo *result;
11662 PyObject * obj0 = 0 ;
11663 char *kwnames[] = {
11664 (char *) "lang", NULL
11665 };
11666
11667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
11668 {
11669 arg1 = (int)(SWIG_As_int(obj0));
11670 if (SWIG_arg_fail(1)) SWIG_fail;
11671 }
11672 {
11673 PyThreadState* __tstate = wxPyBeginAllowThreads();
11674 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
11675
11676 wxPyEndAllowThreads(__tstate);
11677 if (PyErr_Occurred()) SWIG_fail;
11678 }
11679 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11680 return resultobj;
11681 fail:
11682 return NULL;
11683 }
11684
11685
11686 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
11687 PyObject *resultobj;
11688 int arg1 ;
11689 wxString result;
11690 PyObject * obj0 = 0 ;
11691 char *kwnames[] = {
11692 (char *) "lang", NULL
11693 };
11694
11695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
11696 {
11697 arg1 = (int)(SWIG_As_int(obj0));
11698 if (SWIG_arg_fail(1)) SWIG_fail;
11699 }
11700 {
11701 PyThreadState* __tstate = wxPyBeginAllowThreads();
11702 result = wxLocale::GetLanguageName(arg1);
11703
11704 wxPyEndAllowThreads(__tstate);
11705 if (PyErr_Occurred()) SWIG_fail;
11706 }
11707 {
11708 #if wxUSE_UNICODE
11709 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11710 #else
11711 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11712 #endif
11713 }
11714 return resultobj;
11715 fail:
11716 return NULL;
11717 }
11718
11719
11720 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11721 PyObject *resultobj;
11722 wxString *arg1 = 0 ;
11723 wxLanguageInfo *result;
11724 bool temp1 = false ;
11725 PyObject * obj0 = 0 ;
11726 char *kwnames[] = {
11727 (char *) "locale", NULL
11728 };
11729
11730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
11731 {
11732 arg1 = wxString_in_helper(obj0);
11733 if (arg1 == NULL) SWIG_fail;
11734 temp1 = true;
11735 }
11736 {
11737 PyThreadState* __tstate = wxPyBeginAllowThreads();
11738 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
11739
11740 wxPyEndAllowThreads(__tstate);
11741 if (PyErr_Occurred()) SWIG_fail;
11742 }
11743 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11744 {
11745 if (temp1)
11746 delete arg1;
11747 }
11748 return resultobj;
11749 fail:
11750 {
11751 if (temp1)
11752 delete arg1;
11753 }
11754 return NULL;
11755 }
11756
11757
11758 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11759 PyObject *resultobj;
11760 wxLanguageInfo *arg1 = 0 ;
11761 PyObject * obj0 = 0 ;
11762 char *kwnames[] = {
11763 (char *) "info", NULL
11764 };
11765
11766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
11767 {
11768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11769 if (SWIG_arg_fail(1)) SWIG_fail;
11770 if (arg1 == NULL) {
11771 SWIG_null_ref("wxLanguageInfo");
11772 }
11773 if (SWIG_arg_fail(1)) SWIG_fail;
11774 }
11775 {
11776 PyThreadState* __tstate = wxPyBeginAllowThreads();
11777 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
11778
11779 wxPyEndAllowThreads(__tstate);
11780 if (PyErr_Occurred()) SWIG_fail;
11781 }
11782 Py_INCREF(Py_None); resultobj = Py_None;
11783 return resultobj;
11784 fail:
11785 return NULL;
11786 }
11787
11788
11789 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
11790 PyObject *resultobj;
11791 wxLocale *arg1 = (wxLocale *) 0 ;
11792 wxString *arg2 = 0 ;
11793 wxString const &arg3_defvalue = wxPyEmptyString ;
11794 wxString *arg3 = (wxString *) &arg3_defvalue ;
11795 wxString result;
11796 bool temp2 = false ;
11797 bool temp3 = false ;
11798 PyObject * obj0 = 0 ;
11799 PyObject * obj1 = 0 ;
11800 PyObject * obj2 = 0 ;
11801 char *kwnames[] = {
11802 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
11803 };
11804
11805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
11806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11807 if (SWIG_arg_fail(1)) SWIG_fail;
11808 {
11809 arg2 = wxString_in_helper(obj1);
11810 if (arg2 == NULL) SWIG_fail;
11811 temp2 = true;
11812 }
11813 if (obj2) {
11814 {
11815 arg3 = wxString_in_helper(obj2);
11816 if (arg3 == NULL) SWIG_fail;
11817 temp3 = true;
11818 }
11819 }
11820 {
11821 PyThreadState* __tstate = wxPyBeginAllowThreads();
11822 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
11823
11824 wxPyEndAllowThreads(__tstate);
11825 if (PyErr_Occurred()) SWIG_fail;
11826 }
11827 {
11828 #if wxUSE_UNICODE
11829 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11830 #else
11831 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11832 #endif
11833 }
11834 {
11835 if (temp2)
11836 delete arg2;
11837 }
11838 {
11839 if (temp3)
11840 delete arg3;
11841 }
11842 return resultobj;
11843 fail:
11844 {
11845 if (temp2)
11846 delete arg2;
11847 }
11848 {
11849 if (temp3)
11850 delete arg3;
11851 }
11852 return NULL;
11853 }
11854
11855
11856 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
11857 PyObject *resultobj;
11858 wxLocale *arg1 = (wxLocale *) 0 ;
11859 wxString *result;
11860 PyObject * obj0 = 0 ;
11861 char *kwnames[] = {
11862 (char *) "self", NULL
11863 };
11864
11865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
11866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11867 if (SWIG_arg_fail(1)) SWIG_fail;
11868 {
11869 PyThreadState* __tstate = wxPyBeginAllowThreads();
11870 {
11871 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
11872 result = (wxString *) &_result_ref;
11873 }
11874
11875 wxPyEndAllowThreads(__tstate);
11876 if (PyErr_Occurred()) SWIG_fail;
11877 }
11878 {
11879 #if wxUSE_UNICODE
11880 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11881 #else
11882 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11883 #endif
11884 }
11885 return resultobj;
11886 fail:
11887 return NULL;
11888 }
11889
11890
11891 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
11892 PyObject *obj;
11893 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11894 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
11895 Py_INCREF(obj);
11896 return Py_BuildValue((char *)"");
11897 }
11898 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11899 PyObject *resultobj;
11900 wxLocale *result;
11901 char *kwnames[] = {
11902 NULL
11903 };
11904
11905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
11906 {
11907 PyThreadState* __tstate = wxPyBeginAllowThreads();
11908 result = (wxLocale *)wxGetLocale();
11909
11910 wxPyEndAllowThreads(__tstate);
11911 if (PyErr_Occurred()) SWIG_fail;
11912 }
11913 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
11914 return resultobj;
11915 fail:
11916 return NULL;
11917 }
11918
11919
11920 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
11921 PyObject *resultobj;
11922 wxString *arg1 = 0 ;
11923 wxString result;
11924 bool temp1 = false ;
11925 PyObject * obj0 = 0 ;
11926
11927 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
11928 {
11929 arg1 = wxString_in_helper(obj0);
11930 if (arg1 == NULL) SWIG_fail;
11931 temp1 = true;
11932 }
11933 {
11934 PyThreadState* __tstate = wxPyBeginAllowThreads();
11935 result = wxGetTranslation((wxString const &)*arg1);
11936
11937 wxPyEndAllowThreads(__tstate);
11938 if (PyErr_Occurred()) SWIG_fail;
11939 }
11940 {
11941 #if wxUSE_UNICODE
11942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11943 #else
11944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11945 #endif
11946 }
11947 {
11948 if (temp1)
11949 delete arg1;
11950 }
11951 return resultobj;
11952 fail:
11953 {
11954 if (temp1)
11955 delete arg1;
11956 }
11957 return NULL;
11958 }
11959
11960
11961 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
11962 PyObject *resultobj;
11963 wxString *arg1 = 0 ;
11964 wxString *arg2 = 0 ;
11965 size_t arg3 ;
11966 wxString result;
11967 bool temp1 = false ;
11968 bool temp2 = false ;
11969 PyObject * obj0 = 0 ;
11970 PyObject * obj1 = 0 ;
11971 PyObject * obj2 = 0 ;
11972
11973 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
11974 {
11975 arg1 = wxString_in_helper(obj0);
11976 if (arg1 == NULL) SWIG_fail;
11977 temp1 = true;
11978 }
11979 {
11980 arg2 = wxString_in_helper(obj1);
11981 if (arg2 == NULL) SWIG_fail;
11982 temp2 = true;
11983 }
11984 {
11985 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
11986 if (SWIG_arg_fail(3)) SWIG_fail;
11987 }
11988 {
11989 PyThreadState* __tstate = wxPyBeginAllowThreads();
11990 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11991
11992 wxPyEndAllowThreads(__tstate);
11993 if (PyErr_Occurred()) SWIG_fail;
11994 }
11995 {
11996 #if wxUSE_UNICODE
11997 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11998 #else
11999 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12000 #endif
12001 }
12002 {
12003 if (temp1)
12004 delete arg1;
12005 }
12006 {
12007 if (temp2)
12008 delete arg2;
12009 }
12010 return resultobj;
12011 fail:
12012 {
12013 if (temp1)
12014 delete arg1;
12015 }
12016 {
12017 if (temp2)
12018 delete arg2;
12019 }
12020 return NULL;
12021 }
12022
12023
12024 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
12025 int argc;
12026 PyObject *argv[4];
12027 int ii;
12028
12029 argc = PyObject_Length(args);
12030 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
12031 argv[ii] = PyTuple_GetItem(args,ii);
12032 }
12033 if (argc == 1) {
12034 int _v;
12035 {
12036 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12037 }
12038 if (_v) {
12039 return _wrap_GetTranslation__SWIG_0(self,args);
12040 }
12041 }
12042 if (argc == 3) {
12043 int _v;
12044 {
12045 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12046 }
12047 if (_v) {
12048 {
12049 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
12050 }
12051 if (_v) {
12052 _v = SWIG_Check_unsigned_SS_long(argv[2]);
12053 if (_v) {
12054 return _wrap_GetTranslation__SWIG_1(self,args);
12055 }
12056 }
12057 }
12058 }
12059
12060 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
12061 return NULL;
12062 }
12063
12064
12065 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12066 PyObject *resultobj;
12067 wxEncodingConverter *result;
12068 char *kwnames[] = {
12069 NULL
12070 };
12071
12072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
12073 {
12074 PyThreadState* __tstate = wxPyBeginAllowThreads();
12075 result = (wxEncodingConverter *)new wxEncodingConverter();
12076
12077 wxPyEndAllowThreads(__tstate);
12078 if (PyErr_Occurred()) SWIG_fail;
12079 }
12080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
12081 return resultobj;
12082 fail:
12083 return NULL;
12084 }
12085
12086
12087 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12088 PyObject *resultobj;
12089 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12090 PyObject * obj0 = 0 ;
12091 char *kwnames[] = {
12092 (char *) "self", NULL
12093 };
12094
12095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
12096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12097 if (SWIG_arg_fail(1)) SWIG_fail;
12098 {
12099 PyThreadState* __tstate = wxPyBeginAllowThreads();
12100 delete arg1;
12101
12102 wxPyEndAllowThreads(__tstate);
12103 if (PyErr_Occurred()) SWIG_fail;
12104 }
12105 Py_INCREF(Py_None); resultobj = Py_None;
12106 return resultobj;
12107 fail:
12108 return NULL;
12109 }
12110
12111
12112 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
12113 PyObject *resultobj;
12114 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12115 wxFontEncoding arg2 ;
12116 wxFontEncoding arg3 ;
12117 int arg4 = (int) wxCONVERT_STRICT ;
12118 bool result;
12119 PyObject * obj0 = 0 ;
12120 PyObject * obj1 = 0 ;
12121 PyObject * obj2 = 0 ;
12122 PyObject * obj3 = 0 ;
12123 char *kwnames[] = {
12124 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
12125 };
12126
12127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12129 if (SWIG_arg_fail(1)) SWIG_fail;
12130 {
12131 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12132 if (SWIG_arg_fail(2)) SWIG_fail;
12133 }
12134 {
12135 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12136 if (SWIG_arg_fail(3)) SWIG_fail;
12137 }
12138 if (obj3) {
12139 {
12140 arg4 = (int)(SWIG_As_int(obj3));
12141 if (SWIG_arg_fail(4)) SWIG_fail;
12142 }
12143 }
12144 {
12145 PyThreadState* __tstate = wxPyBeginAllowThreads();
12146 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12147
12148 wxPyEndAllowThreads(__tstate);
12149 if (PyErr_Occurred()) SWIG_fail;
12150 }
12151 {
12152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12153 }
12154 return resultobj;
12155 fail:
12156 return NULL;
12157 }
12158
12159
12160 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12161 PyObject *resultobj;
12162 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12163 wxString *arg2 = 0 ;
12164 wxString result;
12165 bool temp2 = false ;
12166 PyObject * obj0 = 0 ;
12167 PyObject * obj1 = 0 ;
12168 char *kwnames[] = {
12169 (char *) "self",(char *) "input", NULL
12170 };
12171
12172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12174 if (SWIG_arg_fail(1)) SWIG_fail;
12175 {
12176 arg2 = wxString_in_helper(obj1);
12177 if (arg2 == NULL) SWIG_fail;
12178 temp2 = true;
12179 }
12180 {
12181 PyThreadState* __tstate = wxPyBeginAllowThreads();
12182 result = (arg1)->Convert((wxString const &)*arg2);
12183
12184 wxPyEndAllowThreads(__tstate);
12185 if (PyErr_Occurred()) SWIG_fail;
12186 }
12187 {
12188 #if wxUSE_UNICODE
12189 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12190 #else
12191 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12192 #endif
12193 }
12194 {
12195 if (temp2)
12196 delete arg2;
12197 }
12198 return resultobj;
12199 fail:
12200 {
12201 if (temp2)
12202 delete arg2;
12203 }
12204 return NULL;
12205 }
12206
12207
12208 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12209 PyObject *resultobj;
12210 wxFontEncoding arg1 ;
12211 int arg2 = (int) wxPLATFORM_CURRENT ;
12212 wxFontEncodingArray result;
12213 PyObject * obj0 = 0 ;
12214 PyObject * obj1 = 0 ;
12215 char *kwnames[] = {
12216 (char *) "enc",(char *) "platform", NULL
12217 };
12218
12219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12220 {
12221 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12222 if (SWIG_arg_fail(1)) SWIG_fail;
12223 }
12224 if (obj1) {
12225 {
12226 arg2 = (int)(SWIG_As_int(obj1));
12227 if (SWIG_arg_fail(2)) SWIG_fail;
12228 }
12229 }
12230 {
12231 PyThreadState* __tstate = wxPyBeginAllowThreads();
12232 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12233
12234 wxPyEndAllowThreads(__tstate);
12235 if (PyErr_Occurred()) SWIG_fail;
12236 }
12237 {
12238 resultobj = PyList_New(0);
12239 for (size_t i=0; i < (&result)->GetCount(); i++) {
12240 PyObject* number = PyInt_FromLong((&result)->Item(i));
12241 PyList_Append(resultobj, number);
12242 Py_DECREF(number);
12243 }
12244 }
12245 return resultobj;
12246 fail:
12247 return NULL;
12248 }
12249
12250
12251 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12252 PyObject *resultobj;
12253 wxFontEncoding arg1 ;
12254 wxFontEncodingArray result;
12255 PyObject * obj0 = 0 ;
12256 char *kwnames[] = {
12257 (char *) "enc", NULL
12258 };
12259
12260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12261 {
12262 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12263 if (SWIG_arg_fail(1)) SWIG_fail;
12264 }
12265 {
12266 PyThreadState* __tstate = wxPyBeginAllowThreads();
12267 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12268
12269 wxPyEndAllowThreads(__tstate);
12270 if (PyErr_Occurred()) SWIG_fail;
12271 }
12272 {
12273 resultobj = PyList_New(0);
12274 for (size_t i=0; i < (&result)->GetCount(); i++) {
12275 PyObject* number = PyInt_FromLong((&result)->Item(i));
12276 PyList_Append(resultobj, number);
12277 Py_DECREF(number);
12278 }
12279 }
12280 return resultobj;
12281 fail:
12282 return NULL;
12283 }
12284
12285
12286 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12287 PyObject *resultobj;
12288 wxFontEncoding arg1 ;
12289 wxFontEncoding arg2 ;
12290 bool result;
12291 PyObject * obj0 = 0 ;
12292 PyObject * obj1 = 0 ;
12293 char *kwnames[] = {
12294 (char *) "encIn",(char *) "encOut", NULL
12295 };
12296
12297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12298 {
12299 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12300 if (SWIG_arg_fail(1)) SWIG_fail;
12301 }
12302 {
12303 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12304 if (SWIG_arg_fail(2)) SWIG_fail;
12305 }
12306 {
12307 PyThreadState* __tstate = wxPyBeginAllowThreads();
12308 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12309
12310 wxPyEndAllowThreads(__tstate);
12311 if (PyErr_Occurred()) SWIG_fail;
12312 }
12313 {
12314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12315 }
12316 return resultobj;
12317 fail:
12318 return NULL;
12319 }
12320
12321
12322 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12323 PyObject *obj;
12324 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12325 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12326 Py_INCREF(obj);
12327 return Py_BuildValue((char *)"");
12328 }
12329 static PyObject *_wrap_delete_DC(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:delete_DC",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 delete arg1;
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_BeginDrawing(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_BeginDrawing",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)->BeginDrawing();
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_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12380 PyObject *resultobj;
12381 wxDC *arg1 = (wxDC *) 0 ;
12382 PyObject * obj0 = 0 ;
12383 char *kwnames[] = {
12384 (char *) "self", NULL
12385 };
12386
12387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12389 if (SWIG_arg_fail(1)) SWIG_fail;
12390 {
12391 PyThreadState* __tstate = wxPyBeginAllowThreads();
12392 (arg1)->EndDrawing();
12393
12394 wxPyEndAllowThreads(__tstate);
12395 if (PyErr_Occurred()) SWIG_fail;
12396 }
12397 Py_INCREF(Py_None); resultobj = Py_None;
12398 return resultobj;
12399 fail:
12400 return NULL;
12401 }
12402
12403
12404 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12405 PyObject *resultobj;
12406 wxDC *arg1 = (wxDC *) 0 ;
12407 int arg2 ;
12408 int arg3 ;
12409 wxColour *arg4 = 0 ;
12410 int arg5 = (int) wxFLOOD_SURFACE ;
12411 bool result;
12412 wxColour temp4 ;
12413 PyObject * obj0 = 0 ;
12414 PyObject * obj1 = 0 ;
12415 PyObject * obj2 = 0 ;
12416 PyObject * obj3 = 0 ;
12417 PyObject * obj4 = 0 ;
12418 char *kwnames[] = {
12419 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12420 };
12421
12422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12424 if (SWIG_arg_fail(1)) SWIG_fail;
12425 {
12426 arg2 = (int)(SWIG_As_int(obj1));
12427 if (SWIG_arg_fail(2)) SWIG_fail;
12428 }
12429 {
12430 arg3 = (int)(SWIG_As_int(obj2));
12431 if (SWIG_arg_fail(3)) SWIG_fail;
12432 }
12433 {
12434 arg4 = &temp4;
12435 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12436 }
12437 if (obj4) {
12438 {
12439 arg5 = (int)(SWIG_As_int(obj4));
12440 if (SWIG_arg_fail(5)) SWIG_fail;
12441 }
12442 }
12443 {
12444 PyThreadState* __tstate = wxPyBeginAllowThreads();
12445 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
12446
12447 wxPyEndAllowThreads(__tstate);
12448 if (PyErr_Occurred()) SWIG_fail;
12449 }
12450 {
12451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12452 }
12453 return resultobj;
12454 fail:
12455 return NULL;
12456 }
12457
12458
12459 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12460 PyObject *resultobj;
12461 wxDC *arg1 = (wxDC *) 0 ;
12462 wxPoint *arg2 = 0 ;
12463 wxColour *arg3 = 0 ;
12464 int arg4 = (int) wxFLOOD_SURFACE ;
12465 bool result;
12466 wxPoint temp2 ;
12467 wxColour temp3 ;
12468 PyObject * obj0 = 0 ;
12469 PyObject * obj1 = 0 ;
12470 PyObject * obj2 = 0 ;
12471 PyObject * obj3 = 0 ;
12472 char *kwnames[] = {
12473 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
12474 };
12475
12476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12478 if (SWIG_arg_fail(1)) SWIG_fail;
12479 {
12480 arg2 = &temp2;
12481 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12482 }
12483 {
12484 arg3 = &temp3;
12485 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
12486 }
12487 if (obj3) {
12488 {
12489 arg4 = (int)(SWIG_As_int(obj3));
12490 if (SWIG_arg_fail(4)) SWIG_fail;
12491 }
12492 }
12493 {
12494 PyThreadState* __tstate = wxPyBeginAllowThreads();
12495 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
12496
12497 wxPyEndAllowThreads(__tstate);
12498 if (PyErr_Occurred()) SWIG_fail;
12499 }
12500 {
12501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12502 }
12503 return resultobj;
12504 fail:
12505 return NULL;
12506 }
12507
12508
12509 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
12510 PyObject *resultobj;
12511 wxDC *arg1 = (wxDC *) 0 ;
12512 int arg2 ;
12513 int arg3 ;
12514 wxColour result;
12515 PyObject * obj0 = 0 ;
12516 PyObject * obj1 = 0 ;
12517 PyObject * obj2 = 0 ;
12518 char *kwnames[] = {
12519 (char *) "self",(char *) "x",(char *) "y", NULL
12520 };
12521
12522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
12523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12524 if (SWIG_arg_fail(1)) SWIG_fail;
12525 {
12526 arg2 = (int)(SWIG_As_int(obj1));
12527 if (SWIG_arg_fail(2)) SWIG_fail;
12528 }
12529 {
12530 arg3 = (int)(SWIG_As_int(obj2));
12531 if (SWIG_arg_fail(3)) SWIG_fail;
12532 }
12533 {
12534 PyThreadState* __tstate = wxPyBeginAllowThreads();
12535 result = wxDC_GetPixel(arg1,arg2,arg3);
12536
12537 wxPyEndAllowThreads(__tstate);
12538 if (PyErr_Occurred()) SWIG_fail;
12539 }
12540 {
12541 wxColour * resultptr;
12542 resultptr = new wxColour((wxColour &)(result));
12543 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12544 }
12545 return resultobj;
12546 fail:
12547 return NULL;
12548 }
12549
12550
12551 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12552 PyObject *resultobj;
12553 wxDC *arg1 = (wxDC *) 0 ;
12554 wxPoint *arg2 = 0 ;
12555 wxColour result;
12556 wxPoint temp2 ;
12557 PyObject * obj0 = 0 ;
12558 PyObject * obj1 = 0 ;
12559 char *kwnames[] = {
12560 (char *) "self",(char *) "pt", NULL
12561 };
12562
12563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
12564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12565 if (SWIG_arg_fail(1)) SWIG_fail;
12566 {
12567 arg2 = &temp2;
12568 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12569 }
12570 {
12571 PyThreadState* __tstate = wxPyBeginAllowThreads();
12572 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
12573
12574 wxPyEndAllowThreads(__tstate);
12575 if (PyErr_Occurred()) SWIG_fail;
12576 }
12577 {
12578 wxColour * resultptr;
12579 resultptr = new wxColour((wxColour &)(result));
12580 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12581 }
12582 return resultobj;
12583 fail:
12584 return NULL;
12585 }
12586
12587
12588 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
12589 PyObject *resultobj;
12590 wxDC *arg1 = (wxDC *) 0 ;
12591 int arg2 ;
12592 int arg3 ;
12593 int arg4 ;
12594 int arg5 ;
12595 PyObject * obj0 = 0 ;
12596 PyObject * obj1 = 0 ;
12597 PyObject * obj2 = 0 ;
12598 PyObject * obj3 = 0 ;
12599 PyObject * obj4 = 0 ;
12600 char *kwnames[] = {
12601 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
12602 };
12603
12604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12606 if (SWIG_arg_fail(1)) SWIG_fail;
12607 {
12608 arg2 = (int)(SWIG_As_int(obj1));
12609 if (SWIG_arg_fail(2)) SWIG_fail;
12610 }
12611 {
12612 arg3 = (int)(SWIG_As_int(obj2));
12613 if (SWIG_arg_fail(3)) SWIG_fail;
12614 }
12615 {
12616 arg4 = (int)(SWIG_As_int(obj3));
12617 if (SWIG_arg_fail(4)) SWIG_fail;
12618 }
12619 {
12620 arg5 = (int)(SWIG_As_int(obj4));
12621 if (SWIG_arg_fail(5)) SWIG_fail;
12622 }
12623 {
12624 PyThreadState* __tstate = wxPyBeginAllowThreads();
12625 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
12626
12627 wxPyEndAllowThreads(__tstate);
12628 if (PyErr_Occurred()) SWIG_fail;
12629 }
12630 Py_INCREF(Py_None); resultobj = Py_None;
12631 return resultobj;
12632 fail:
12633 return NULL;
12634 }
12635
12636
12637 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
12638 PyObject *resultobj;
12639 wxDC *arg1 = (wxDC *) 0 ;
12640 wxPoint *arg2 = 0 ;
12641 wxPoint *arg3 = 0 ;
12642 wxPoint temp2 ;
12643 wxPoint temp3 ;
12644 PyObject * obj0 = 0 ;
12645 PyObject * obj1 = 0 ;
12646 PyObject * obj2 = 0 ;
12647 char *kwnames[] = {
12648 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
12649 };
12650
12651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12653 if (SWIG_arg_fail(1)) SWIG_fail;
12654 {
12655 arg2 = &temp2;
12656 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12657 }
12658 {
12659 arg3 = &temp3;
12660 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12661 }
12662 {
12663 PyThreadState* __tstate = wxPyBeginAllowThreads();
12664 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
12665
12666 wxPyEndAllowThreads(__tstate);
12667 if (PyErr_Occurred()) SWIG_fail;
12668 }
12669 Py_INCREF(Py_None); resultobj = Py_None;
12670 return resultobj;
12671 fail:
12672 return NULL;
12673 }
12674
12675
12676 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
12677 PyObject *resultobj;
12678 wxDC *arg1 = (wxDC *) 0 ;
12679 int arg2 ;
12680 int arg3 ;
12681 PyObject * obj0 = 0 ;
12682 PyObject * obj1 = 0 ;
12683 PyObject * obj2 = 0 ;
12684 char *kwnames[] = {
12685 (char *) "self",(char *) "x",(char *) "y", NULL
12686 };
12687
12688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
12689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12690 if (SWIG_arg_fail(1)) SWIG_fail;
12691 {
12692 arg2 = (int)(SWIG_As_int(obj1));
12693 if (SWIG_arg_fail(2)) SWIG_fail;
12694 }
12695 {
12696 arg3 = (int)(SWIG_As_int(obj2));
12697 if (SWIG_arg_fail(3)) SWIG_fail;
12698 }
12699 {
12700 PyThreadState* __tstate = wxPyBeginAllowThreads();
12701 (arg1)->CrossHair(arg2,arg3);
12702
12703 wxPyEndAllowThreads(__tstate);
12704 if (PyErr_Occurred()) SWIG_fail;
12705 }
12706 Py_INCREF(Py_None); resultobj = Py_None;
12707 return resultobj;
12708 fail:
12709 return NULL;
12710 }
12711
12712
12713 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12714 PyObject *resultobj;
12715 wxDC *arg1 = (wxDC *) 0 ;
12716 wxPoint *arg2 = 0 ;
12717 wxPoint temp2 ;
12718 PyObject * obj0 = 0 ;
12719 PyObject * obj1 = 0 ;
12720 char *kwnames[] = {
12721 (char *) "self",(char *) "pt", NULL
12722 };
12723
12724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
12725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12726 if (SWIG_arg_fail(1)) SWIG_fail;
12727 {
12728 arg2 = &temp2;
12729 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12730 }
12731 {
12732 PyThreadState* __tstate = wxPyBeginAllowThreads();
12733 (arg1)->CrossHair((wxPoint const &)*arg2);
12734
12735 wxPyEndAllowThreads(__tstate);
12736 if (PyErr_Occurred()) SWIG_fail;
12737 }
12738 Py_INCREF(Py_None); resultobj = Py_None;
12739 return resultobj;
12740 fail:
12741 return NULL;
12742 }
12743
12744
12745 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
12746 PyObject *resultobj;
12747 wxDC *arg1 = (wxDC *) 0 ;
12748 int arg2 ;
12749 int arg3 ;
12750 int arg4 ;
12751 int arg5 ;
12752 int arg6 ;
12753 int arg7 ;
12754 PyObject * obj0 = 0 ;
12755 PyObject * obj1 = 0 ;
12756 PyObject * obj2 = 0 ;
12757 PyObject * obj3 = 0 ;
12758 PyObject * obj4 = 0 ;
12759 PyObject * obj5 = 0 ;
12760 PyObject * obj6 = 0 ;
12761 char *kwnames[] = {
12762 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
12763 };
12764
12765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12767 if (SWIG_arg_fail(1)) SWIG_fail;
12768 {
12769 arg2 = (int)(SWIG_As_int(obj1));
12770 if (SWIG_arg_fail(2)) SWIG_fail;
12771 }
12772 {
12773 arg3 = (int)(SWIG_As_int(obj2));
12774 if (SWIG_arg_fail(3)) SWIG_fail;
12775 }
12776 {
12777 arg4 = (int)(SWIG_As_int(obj3));
12778 if (SWIG_arg_fail(4)) SWIG_fail;
12779 }
12780 {
12781 arg5 = (int)(SWIG_As_int(obj4));
12782 if (SWIG_arg_fail(5)) SWIG_fail;
12783 }
12784 {
12785 arg6 = (int)(SWIG_As_int(obj5));
12786 if (SWIG_arg_fail(6)) SWIG_fail;
12787 }
12788 {
12789 arg7 = (int)(SWIG_As_int(obj6));
12790 if (SWIG_arg_fail(7)) SWIG_fail;
12791 }
12792 {
12793 PyThreadState* __tstate = wxPyBeginAllowThreads();
12794 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
12795
12796 wxPyEndAllowThreads(__tstate);
12797 if (PyErr_Occurred()) SWIG_fail;
12798 }
12799 Py_INCREF(Py_None); resultobj = Py_None;
12800 return resultobj;
12801 fail:
12802 return NULL;
12803 }
12804
12805
12806 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12807 PyObject *resultobj;
12808 wxDC *arg1 = (wxDC *) 0 ;
12809 wxPoint *arg2 = 0 ;
12810 wxPoint *arg3 = 0 ;
12811 wxPoint *arg4 = 0 ;
12812 wxPoint temp2 ;
12813 wxPoint temp3 ;
12814 wxPoint temp4 ;
12815 PyObject * obj0 = 0 ;
12816 PyObject * obj1 = 0 ;
12817 PyObject * obj2 = 0 ;
12818 PyObject * obj3 = 0 ;
12819 char *kwnames[] = {
12820 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
12821 };
12822
12823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12825 if (SWIG_arg_fail(1)) SWIG_fail;
12826 {
12827 arg2 = &temp2;
12828 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12829 }
12830 {
12831 arg3 = &temp3;
12832 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12833 }
12834 {
12835 arg4 = &temp4;
12836 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12837 }
12838 {
12839 PyThreadState* __tstate = wxPyBeginAllowThreads();
12840 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
12841
12842 wxPyEndAllowThreads(__tstate);
12843 if (PyErr_Occurred()) SWIG_fail;
12844 }
12845 Py_INCREF(Py_None); resultobj = Py_None;
12846 return resultobj;
12847 fail:
12848 return NULL;
12849 }
12850
12851
12852 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
12853 PyObject *resultobj;
12854 wxDC *arg1 = (wxDC *) 0 ;
12855 int arg2 ;
12856 int arg3 ;
12857 int arg4 ;
12858 int arg5 ;
12859 PyObject * obj0 = 0 ;
12860 PyObject * obj1 = 0 ;
12861 PyObject * obj2 = 0 ;
12862 PyObject * obj3 = 0 ;
12863 PyObject * obj4 = 0 ;
12864 char *kwnames[] = {
12865 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
12866 };
12867
12868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12870 if (SWIG_arg_fail(1)) SWIG_fail;
12871 {
12872 arg2 = (int)(SWIG_As_int(obj1));
12873 if (SWIG_arg_fail(2)) SWIG_fail;
12874 }
12875 {
12876 arg3 = (int)(SWIG_As_int(obj2));
12877 if (SWIG_arg_fail(3)) SWIG_fail;
12878 }
12879 {
12880 arg4 = (int)(SWIG_As_int(obj3));
12881 if (SWIG_arg_fail(4)) SWIG_fail;
12882 }
12883 {
12884 arg5 = (int)(SWIG_As_int(obj4));
12885 if (SWIG_arg_fail(5)) SWIG_fail;
12886 }
12887 {
12888 PyThreadState* __tstate = wxPyBeginAllowThreads();
12889 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
12890
12891 wxPyEndAllowThreads(__tstate);
12892 if (PyErr_Occurred()) SWIG_fail;
12893 }
12894 Py_INCREF(Py_None); resultobj = Py_None;
12895 return resultobj;
12896 fail:
12897 return NULL;
12898 }
12899
12900
12901 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
12902 PyObject *resultobj;
12903 wxDC *arg1 = (wxDC *) 0 ;
12904 wxRect *arg2 = 0 ;
12905 wxRect temp2 ;
12906 PyObject * obj0 = 0 ;
12907 PyObject * obj1 = 0 ;
12908 char *kwnames[] = {
12909 (char *) "self",(char *) "rect", NULL
12910 };
12911
12912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
12913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12914 if (SWIG_arg_fail(1)) SWIG_fail;
12915 {
12916 arg2 = &temp2;
12917 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12918 }
12919 {
12920 PyThreadState* __tstate = wxPyBeginAllowThreads();
12921 (arg1)->DrawCheckMark((wxRect const &)*arg2);
12922
12923 wxPyEndAllowThreads(__tstate);
12924 if (PyErr_Occurred()) SWIG_fail;
12925 }
12926 Py_INCREF(Py_None); resultobj = Py_None;
12927 return resultobj;
12928 fail:
12929 return NULL;
12930 }
12931
12932
12933 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
12934 PyObject *resultobj;
12935 wxDC *arg1 = (wxDC *) 0 ;
12936 int arg2 ;
12937 int arg3 ;
12938 int arg4 ;
12939 int arg5 ;
12940 double arg6 ;
12941 double arg7 ;
12942 PyObject * obj0 = 0 ;
12943 PyObject * obj1 = 0 ;
12944 PyObject * obj2 = 0 ;
12945 PyObject * obj3 = 0 ;
12946 PyObject * obj4 = 0 ;
12947 PyObject * obj5 = 0 ;
12948 PyObject * obj6 = 0 ;
12949 char *kwnames[] = {
12950 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
12951 };
12952
12953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12955 if (SWIG_arg_fail(1)) SWIG_fail;
12956 {
12957 arg2 = (int)(SWIG_As_int(obj1));
12958 if (SWIG_arg_fail(2)) SWIG_fail;
12959 }
12960 {
12961 arg3 = (int)(SWIG_As_int(obj2));
12962 if (SWIG_arg_fail(3)) SWIG_fail;
12963 }
12964 {
12965 arg4 = (int)(SWIG_As_int(obj3));
12966 if (SWIG_arg_fail(4)) SWIG_fail;
12967 }
12968 {
12969 arg5 = (int)(SWIG_As_int(obj4));
12970 if (SWIG_arg_fail(5)) SWIG_fail;
12971 }
12972 {
12973 arg6 = (double)(SWIG_As_double(obj5));
12974 if (SWIG_arg_fail(6)) SWIG_fail;
12975 }
12976 {
12977 arg7 = (double)(SWIG_As_double(obj6));
12978 if (SWIG_arg_fail(7)) SWIG_fail;
12979 }
12980 {
12981 PyThreadState* __tstate = wxPyBeginAllowThreads();
12982 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
12983
12984 wxPyEndAllowThreads(__tstate);
12985 if (PyErr_Occurred()) SWIG_fail;
12986 }
12987 Py_INCREF(Py_None); resultobj = Py_None;
12988 return resultobj;
12989 fail:
12990 return NULL;
12991 }
12992
12993
12994 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
12995 PyObject *resultobj;
12996 wxDC *arg1 = (wxDC *) 0 ;
12997 wxPoint *arg2 = 0 ;
12998 wxSize *arg3 = 0 ;
12999 double arg4 ;
13000 double arg5 ;
13001 wxPoint temp2 ;
13002 wxSize temp3 ;
13003 PyObject * obj0 = 0 ;
13004 PyObject * obj1 = 0 ;
13005 PyObject * obj2 = 0 ;
13006 PyObject * obj3 = 0 ;
13007 PyObject * obj4 = 0 ;
13008 char *kwnames[] = {
13009 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
13010 };
13011
13012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13014 if (SWIG_arg_fail(1)) SWIG_fail;
13015 {
13016 arg2 = &temp2;
13017 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13018 }
13019 {
13020 arg3 = &temp3;
13021 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13022 }
13023 {
13024 arg4 = (double)(SWIG_As_double(obj3));
13025 if (SWIG_arg_fail(4)) SWIG_fail;
13026 }
13027 {
13028 arg5 = (double)(SWIG_As_double(obj4));
13029 if (SWIG_arg_fail(5)) SWIG_fail;
13030 }
13031 {
13032 PyThreadState* __tstate = wxPyBeginAllowThreads();
13033 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
13034
13035 wxPyEndAllowThreads(__tstate);
13036 if (PyErr_Occurred()) SWIG_fail;
13037 }
13038 Py_INCREF(Py_None); resultobj = Py_None;
13039 return resultobj;
13040 fail:
13041 return NULL;
13042 }
13043
13044
13045 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13046 PyObject *resultobj;
13047 wxDC *arg1 = (wxDC *) 0 ;
13048 int arg2 ;
13049 int arg3 ;
13050 PyObject * obj0 = 0 ;
13051 PyObject * obj1 = 0 ;
13052 PyObject * obj2 = 0 ;
13053 char *kwnames[] = {
13054 (char *) "self",(char *) "x",(char *) "y", NULL
13055 };
13056
13057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13059 if (SWIG_arg_fail(1)) SWIG_fail;
13060 {
13061 arg2 = (int)(SWIG_As_int(obj1));
13062 if (SWIG_arg_fail(2)) SWIG_fail;
13063 }
13064 {
13065 arg3 = (int)(SWIG_As_int(obj2));
13066 if (SWIG_arg_fail(3)) SWIG_fail;
13067 }
13068 {
13069 PyThreadState* __tstate = wxPyBeginAllowThreads();
13070 (arg1)->DrawPoint(arg2,arg3);
13071
13072 wxPyEndAllowThreads(__tstate);
13073 if (PyErr_Occurred()) SWIG_fail;
13074 }
13075 Py_INCREF(Py_None); resultobj = Py_None;
13076 return resultobj;
13077 fail:
13078 return NULL;
13079 }
13080
13081
13082 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13083 PyObject *resultobj;
13084 wxDC *arg1 = (wxDC *) 0 ;
13085 wxPoint *arg2 = 0 ;
13086 wxPoint temp2 ;
13087 PyObject * obj0 = 0 ;
13088 PyObject * obj1 = 0 ;
13089 char *kwnames[] = {
13090 (char *) "self",(char *) "pt", NULL
13091 };
13092
13093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
13094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13095 if (SWIG_arg_fail(1)) SWIG_fail;
13096 {
13097 arg2 = &temp2;
13098 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13099 }
13100 {
13101 PyThreadState* __tstate = wxPyBeginAllowThreads();
13102 (arg1)->DrawPoint((wxPoint const &)*arg2);
13103
13104 wxPyEndAllowThreads(__tstate);
13105 if (PyErr_Occurred()) SWIG_fail;
13106 }
13107 Py_INCREF(Py_None); resultobj = Py_None;
13108 return resultobj;
13109 fail:
13110 return NULL;
13111 }
13112
13113
13114 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13115 PyObject *resultobj;
13116 wxDC *arg1 = (wxDC *) 0 ;
13117 int arg2 ;
13118 int arg3 ;
13119 int arg4 ;
13120 int arg5 ;
13121 PyObject * obj0 = 0 ;
13122 PyObject * obj1 = 0 ;
13123 PyObject * obj2 = 0 ;
13124 PyObject * obj3 = 0 ;
13125 PyObject * obj4 = 0 ;
13126 char *kwnames[] = {
13127 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13128 };
13129
13130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13132 if (SWIG_arg_fail(1)) SWIG_fail;
13133 {
13134 arg2 = (int)(SWIG_As_int(obj1));
13135 if (SWIG_arg_fail(2)) SWIG_fail;
13136 }
13137 {
13138 arg3 = (int)(SWIG_As_int(obj2));
13139 if (SWIG_arg_fail(3)) SWIG_fail;
13140 }
13141 {
13142 arg4 = (int)(SWIG_As_int(obj3));
13143 if (SWIG_arg_fail(4)) SWIG_fail;
13144 }
13145 {
13146 arg5 = (int)(SWIG_As_int(obj4));
13147 if (SWIG_arg_fail(5)) SWIG_fail;
13148 }
13149 {
13150 PyThreadState* __tstate = wxPyBeginAllowThreads();
13151 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13152
13153 wxPyEndAllowThreads(__tstate);
13154 if (PyErr_Occurred()) SWIG_fail;
13155 }
13156 Py_INCREF(Py_None); resultobj = Py_None;
13157 return resultobj;
13158 fail:
13159 return NULL;
13160 }
13161
13162
13163 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13164 PyObject *resultobj;
13165 wxDC *arg1 = (wxDC *) 0 ;
13166 wxRect *arg2 = 0 ;
13167 wxRect temp2 ;
13168 PyObject * obj0 = 0 ;
13169 PyObject * obj1 = 0 ;
13170 char *kwnames[] = {
13171 (char *) "self",(char *) "rect", NULL
13172 };
13173
13174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13176 if (SWIG_arg_fail(1)) SWIG_fail;
13177 {
13178 arg2 = &temp2;
13179 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13180 }
13181 {
13182 PyThreadState* __tstate = wxPyBeginAllowThreads();
13183 (arg1)->DrawRectangle((wxRect const &)*arg2);
13184
13185 wxPyEndAllowThreads(__tstate);
13186 if (PyErr_Occurred()) SWIG_fail;
13187 }
13188 Py_INCREF(Py_None); resultobj = Py_None;
13189 return resultobj;
13190 fail:
13191 return NULL;
13192 }
13193
13194
13195 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13196 PyObject *resultobj;
13197 wxDC *arg1 = (wxDC *) 0 ;
13198 wxPoint *arg2 = 0 ;
13199 wxSize *arg3 = 0 ;
13200 wxPoint temp2 ;
13201 wxSize temp3 ;
13202 PyObject * obj0 = 0 ;
13203 PyObject * obj1 = 0 ;
13204 PyObject * obj2 = 0 ;
13205 char *kwnames[] = {
13206 (char *) "self",(char *) "pt",(char *) "sz", NULL
13207 };
13208
13209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13211 if (SWIG_arg_fail(1)) SWIG_fail;
13212 {
13213 arg2 = &temp2;
13214 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13215 }
13216 {
13217 arg3 = &temp3;
13218 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13219 }
13220 {
13221 PyThreadState* __tstate = wxPyBeginAllowThreads();
13222 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13223
13224 wxPyEndAllowThreads(__tstate);
13225 if (PyErr_Occurred()) SWIG_fail;
13226 }
13227 Py_INCREF(Py_None); resultobj = Py_None;
13228 return resultobj;
13229 fail:
13230 return NULL;
13231 }
13232
13233
13234 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13235 PyObject *resultobj;
13236 wxDC *arg1 = (wxDC *) 0 ;
13237 int arg2 ;
13238 int arg3 ;
13239 int arg4 ;
13240 int arg5 ;
13241 double arg6 ;
13242 PyObject * obj0 = 0 ;
13243 PyObject * obj1 = 0 ;
13244 PyObject * obj2 = 0 ;
13245 PyObject * obj3 = 0 ;
13246 PyObject * obj4 = 0 ;
13247 PyObject * obj5 = 0 ;
13248 char *kwnames[] = {
13249 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13250 };
13251
13252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13254 if (SWIG_arg_fail(1)) SWIG_fail;
13255 {
13256 arg2 = (int)(SWIG_As_int(obj1));
13257 if (SWIG_arg_fail(2)) SWIG_fail;
13258 }
13259 {
13260 arg3 = (int)(SWIG_As_int(obj2));
13261 if (SWIG_arg_fail(3)) SWIG_fail;
13262 }
13263 {
13264 arg4 = (int)(SWIG_As_int(obj3));
13265 if (SWIG_arg_fail(4)) SWIG_fail;
13266 }
13267 {
13268 arg5 = (int)(SWIG_As_int(obj4));
13269 if (SWIG_arg_fail(5)) SWIG_fail;
13270 }
13271 {
13272 arg6 = (double)(SWIG_As_double(obj5));
13273 if (SWIG_arg_fail(6)) SWIG_fail;
13274 }
13275 {
13276 PyThreadState* __tstate = wxPyBeginAllowThreads();
13277 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13278
13279 wxPyEndAllowThreads(__tstate);
13280 if (PyErr_Occurred()) SWIG_fail;
13281 }
13282 Py_INCREF(Py_None); resultobj = Py_None;
13283 return resultobj;
13284 fail:
13285 return NULL;
13286 }
13287
13288
13289 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13290 PyObject *resultobj;
13291 wxDC *arg1 = (wxDC *) 0 ;
13292 wxRect *arg2 = 0 ;
13293 double arg3 ;
13294 wxRect temp2 ;
13295 PyObject * obj0 = 0 ;
13296 PyObject * obj1 = 0 ;
13297 PyObject * obj2 = 0 ;
13298 char *kwnames[] = {
13299 (char *) "self",(char *) "r",(char *) "radius", NULL
13300 };
13301
13302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13304 if (SWIG_arg_fail(1)) SWIG_fail;
13305 {
13306 arg2 = &temp2;
13307 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13308 }
13309 {
13310 arg3 = (double)(SWIG_As_double(obj2));
13311 if (SWIG_arg_fail(3)) SWIG_fail;
13312 }
13313 {
13314 PyThreadState* __tstate = wxPyBeginAllowThreads();
13315 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13316
13317 wxPyEndAllowThreads(__tstate);
13318 if (PyErr_Occurred()) SWIG_fail;
13319 }
13320 Py_INCREF(Py_None); resultobj = Py_None;
13321 return resultobj;
13322 fail:
13323 return NULL;
13324 }
13325
13326
13327 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13328 PyObject *resultobj;
13329 wxDC *arg1 = (wxDC *) 0 ;
13330 wxPoint *arg2 = 0 ;
13331 wxSize *arg3 = 0 ;
13332 double arg4 ;
13333 wxPoint temp2 ;
13334 wxSize temp3 ;
13335 PyObject * obj0 = 0 ;
13336 PyObject * obj1 = 0 ;
13337 PyObject * obj2 = 0 ;
13338 PyObject * obj3 = 0 ;
13339 char *kwnames[] = {
13340 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13341 };
13342
13343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13345 if (SWIG_arg_fail(1)) SWIG_fail;
13346 {
13347 arg2 = &temp2;
13348 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13349 }
13350 {
13351 arg3 = &temp3;
13352 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13353 }
13354 {
13355 arg4 = (double)(SWIG_As_double(obj3));
13356 if (SWIG_arg_fail(4)) SWIG_fail;
13357 }
13358 {
13359 PyThreadState* __tstate = wxPyBeginAllowThreads();
13360 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13361
13362 wxPyEndAllowThreads(__tstate);
13363 if (PyErr_Occurred()) SWIG_fail;
13364 }
13365 Py_INCREF(Py_None); resultobj = Py_None;
13366 return resultobj;
13367 fail:
13368 return NULL;
13369 }
13370
13371
13372 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13373 PyObject *resultobj;
13374 wxDC *arg1 = (wxDC *) 0 ;
13375 int arg2 ;
13376 int arg3 ;
13377 int arg4 ;
13378 PyObject * obj0 = 0 ;
13379 PyObject * obj1 = 0 ;
13380 PyObject * obj2 = 0 ;
13381 PyObject * obj3 = 0 ;
13382 char *kwnames[] = {
13383 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13384 };
13385
13386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13388 if (SWIG_arg_fail(1)) SWIG_fail;
13389 {
13390 arg2 = (int)(SWIG_As_int(obj1));
13391 if (SWIG_arg_fail(2)) SWIG_fail;
13392 }
13393 {
13394 arg3 = (int)(SWIG_As_int(obj2));
13395 if (SWIG_arg_fail(3)) SWIG_fail;
13396 }
13397 {
13398 arg4 = (int)(SWIG_As_int(obj3));
13399 if (SWIG_arg_fail(4)) SWIG_fail;
13400 }
13401 {
13402 PyThreadState* __tstate = wxPyBeginAllowThreads();
13403 (arg1)->DrawCircle(arg2,arg3,arg4);
13404
13405 wxPyEndAllowThreads(__tstate);
13406 if (PyErr_Occurred()) SWIG_fail;
13407 }
13408 Py_INCREF(Py_None); resultobj = Py_None;
13409 return resultobj;
13410 fail:
13411 return NULL;
13412 }
13413
13414
13415 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13416 PyObject *resultobj;
13417 wxDC *arg1 = (wxDC *) 0 ;
13418 wxPoint *arg2 = 0 ;
13419 int arg3 ;
13420 wxPoint temp2 ;
13421 PyObject * obj0 = 0 ;
13422 PyObject * obj1 = 0 ;
13423 PyObject * obj2 = 0 ;
13424 char *kwnames[] = {
13425 (char *) "self",(char *) "pt",(char *) "radius", NULL
13426 };
13427
13428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13430 if (SWIG_arg_fail(1)) SWIG_fail;
13431 {
13432 arg2 = &temp2;
13433 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13434 }
13435 {
13436 arg3 = (int)(SWIG_As_int(obj2));
13437 if (SWIG_arg_fail(3)) SWIG_fail;
13438 }
13439 {
13440 PyThreadState* __tstate = wxPyBeginAllowThreads();
13441 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13442
13443 wxPyEndAllowThreads(__tstate);
13444 if (PyErr_Occurred()) SWIG_fail;
13445 }
13446 Py_INCREF(Py_None); resultobj = Py_None;
13447 return resultobj;
13448 fail:
13449 return NULL;
13450 }
13451
13452
13453 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
13454 PyObject *resultobj;
13455 wxDC *arg1 = (wxDC *) 0 ;
13456 int arg2 ;
13457 int arg3 ;
13458 int arg4 ;
13459 int arg5 ;
13460 PyObject * obj0 = 0 ;
13461 PyObject * obj1 = 0 ;
13462 PyObject * obj2 = 0 ;
13463 PyObject * obj3 = 0 ;
13464 PyObject * obj4 = 0 ;
13465 char *kwnames[] = {
13466 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13467 };
13468
13469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13471 if (SWIG_arg_fail(1)) SWIG_fail;
13472 {
13473 arg2 = (int)(SWIG_As_int(obj1));
13474 if (SWIG_arg_fail(2)) SWIG_fail;
13475 }
13476 {
13477 arg3 = (int)(SWIG_As_int(obj2));
13478 if (SWIG_arg_fail(3)) SWIG_fail;
13479 }
13480 {
13481 arg4 = (int)(SWIG_As_int(obj3));
13482 if (SWIG_arg_fail(4)) SWIG_fail;
13483 }
13484 {
13485 arg5 = (int)(SWIG_As_int(obj4));
13486 if (SWIG_arg_fail(5)) SWIG_fail;
13487 }
13488 {
13489 PyThreadState* __tstate = wxPyBeginAllowThreads();
13490 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
13491
13492 wxPyEndAllowThreads(__tstate);
13493 if (PyErr_Occurred()) SWIG_fail;
13494 }
13495 Py_INCREF(Py_None); resultobj = Py_None;
13496 return resultobj;
13497 fail:
13498 return NULL;
13499 }
13500
13501
13502 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
13503 PyObject *resultobj;
13504 wxDC *arg1 = (wxDC *) 0 ;
13505 wxRect *arg2 = 0 ;
13506 wxRect temp2 ;
13507 PyObject * obj0 = 0 ;
13508 PyObject * obj1 = 0 ;
13509 char *kwnames[] = {
13510 (char *) "self",(char *) "rect", NULL
13511 };
13512
13513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
13514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13515 if (SWIG_arg_fail(1)) SWIG_fail;
13516 {
13517 arg2 = &temp2;
13518 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13519 }
13520 {
13521 PyThreadState* __tstate = wxPyBeginAllowThreads();
13522 (arg1)->DrawEllipse((wxRect const &)*arg2);
13523
13524 wxPyEndAllowThreads(__tstate);
13525 if (PyErr_Occurred()) SWIG_fail;
13526 }
13527 Py_INCREF(Py_None); resultobj = Py_None;
13528 return resultobj;
13529 fail:
13530 return NULL;
13531 }
13532
13533
13534 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13535 PyObject *resultobj;
13536 wxDC *arg1 = (wxDC *) 0 ;
13537 wxPoint *arg2 = 0 ;
13538 wxSize *arg3 = 0 ;
13539 wxPoint temp2 ;
13540 wxSize temp3 ;
13541 PyObject * obj0 = 0 ;
13542 PyObject * obj1 = 0 ;
13543 PyObject * obj2 = 0 ;
13544 char *kwnames[] = {
13545 (char *) "self",(char *) "pt",(char *) "sz", NULL
13546 };
13547
13548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13550 if (SWIG_arg_fail(1)) SWIG_fail;
13551 {
13552 arg2 = &temp2;
13553 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13554 }
13555 {
13556 arg3 = &temp3;
13557 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13558 }
13559 {
13560 PyThreadState* __tstate = wxPyBeginAllowThreads();
13561 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
13562
13563 wxPyEndAllowThreads(__tstate);
13564 if (PyErr_Occurred()) SWIG_fail;
13565 }
13566 Py_INCREF(Py_None); resultobj = Py_None;
13567 return resultobj;
13568 fail:
13569 return NULL;
13570 }
13571
13572
13573 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13574 PyObject *resultobj;
13575 wxDC *arg1 = (wxDC *) 0 ;
13576 wxIcon *arg2 = 0 ;
13577 int arg3 ;
13578 int arg4 ;
13579 PyObject * obj0 = 0 ;
13580 PyObject * obj1 = 0 ;
13581 PyObject * obj2 = 0 ;
13582 PyObject * obj3 = 0 ;
13583 char *kwnames[] = {
13584 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
13585 };
13586
13587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13589 if (SWIG_arg_fail(1)) SWIG_fail;
13590 {
13591 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13592 if (SWIG_arg_fail(2)) SWIG_fail;
13593 if (arg2 == NULL) {
13594 SWIG_null_ref("wxIcon");
13595 }
13596 if (SWIG_arg_fail(2)) SWIG_fail;
13597 }
13598 {
13599 arg3 = (int)(SWIG_As_int(obj2));
13600 if (SWIG_arg_fail(3)) SWIG_fail;
13601 }
13602 {
13603 arg4 = (int)(SWIG_As_int(obj3));
13604 if (SWIG_arg_fail(4)) SWIG_fail;
13605 }
13606 {
13607 PyThreadState* __tstate = wxPyBeginAllowThreads();
13608 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
13609
13610 wxPyEndAllowThreads(__tstate);
13611 if (PyErr_Occurred()) SWIG_fail;
13612 }
13613 Py_INCREF(Py_None); resultobj = Py_None;
13614 return resultobj;
13615 fail:
13616 return NULL;
13617 }
13618
13619
13620 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13621 PyObject *resultobj;
13622 wxDC *arg1 = (wxDC *) 0 ;
13623 wxIcon *arg2 = 0 ;
13624 wxPoint *arg3 = 0 ;
13625 wxPoint temp3 ;
13626 PyObject * obj0 = 0 ;
13627 PyObject * obj1 = 0 ;
13628 PyObject * obj2 = 0 ;
13629 char *kwnames[] = {
13630 (char *) "self",(char *) "icon",(char *) "pt", NULL
13631 };
13632
13633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13635 if (SWIG_arg_fail(1)) SWIG_fail;
13636 {
13637 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13638 if (SWIG_arg_fail(2)) SWIG_fail;
13639 if (arg2 == NULL) {
13640 SWIG_null_ref("wxIcon");
13641 }
13642 if (SWIG_arg_fail(2)) SWIG_fail;
13643 }
13644 {
13645 arg3 = &temp3;
13646 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13647 }
13648 {
13649 PyThreadState* __tstate = wxPyBeginAllowThreads();
13650 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
13651
13652 wxPyEndAllowThreads(__tstate);
13653 if (PyErr_Occurred()) SWIG_fail;
13654 }
13655 Py_INCREF(Py_None); resultobj = Py_None;
13656 return resultobj;
13657 fail:
13658 return NULL;
13659 }
13660
13661
13662 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13663 PyObject *resultobj;
13664 wxDC *arg1 = (wxDC *) 0 ;
13665 wxBitmap *arg2 = 0 ;
13666 int arg3 ;
13667 int arg4 ;
13668 bool arg5 = (bool) false ;
13669 PyObject * obj0 = 0 ;
13670 PyObject * obj1 = 0 ;
13671 PyObject * obj2 = 0 ;
13672 PyObject * obj3 = 0 ;
13673 PyObject * obj4 = 0 ;
13674 char *kwnames[] = {
13675 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
13676 };
13677
13678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13680 if (SWIG_arg_fail(1)) SWIG_fail;
13681 {
13682 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13683 if (SWIG_arg_fail(2)) SWIG_fail;
13684 if (arg2 == NULL) {
13685 SWIG_null_ref("wxBitmap");
13686 }
13687 if (SWIG_arg_fail(2)) SWIG_fail;
13688 }
13689 {
13690 arg3 = (int)(SWIG_As_int(obj2));
13691 if (SWIG_arg_fail(3)) SWIG_fail;
13692 }
13693 {
13694 arg4 = (int)(SWIG_As_int(obj3));
13695 if (SWIG_arg_fail(4)) SWIG_fail;
13696 }
13697 if (obj4) {
13698 {
13699 arg5 = (bool)(SWIG_As_bool(obj4));
13700 if (SWIG_arg_fail(5)) SWIG_fail;
13701 }
13702 }
13703 {
13704 PyThreadState* __tstate = wxPyBeginAllowThreads();
13705 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
13706
13707 wxPyEndAllowThreads(__tstate);
13708 if (PyErr_Occurred()) SWIG_fail;
13709 }
13710 Py_INCREF(Py_None); resultobj = Py_None;
13711 return resultobj;
13712 fail:
13713 return NULL;
13714 }
13715
13716
13717 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13718 PyObject *resultobj;
13719 wxDC *arg1 = (wxDC *) 0 ;
13720 wxBitmap *arg2 = 0 ;
13721 wxPoint *arg3 = 0 ;
13722 bool arg4 = (bool) false ;
13723 wxPoint temp3 ;
13724 PyObject * obj0 = 0 ;
13725 PyObject * obj1 = 0 ;
13726 PyObject * obj2 = 0 ;
13727 PyObject * obj3 = 0 ;
13728 char *kwnames[] = {
13729 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
13730 };
13731
13732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13734 if (SWIG_arg_fail(1)) SWIG_fail;
13735 {
13736 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13737 if (SWIG_arg_fail(2)) SWIG_fail;
13738 if (arg2 == NULL) {
13739 SWIG_null_ref("wxBitmap");
13740 }
13741 if (SWIG_arg_fail(2)) SWIG_fail;
13742 }
13743 {
13744 arg3 = &temp3;
13745 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13746 }
13747 if (obj3) {
13748 {
13749 arg4 = (bool)(SWIG_As_bool(obj3));
13750 if (SWIG_arg_fail(4)) SWIG_fail;
13751 }
13752 }
13753 {
13754 PyThreadState* __tstate = wxPyBeginAllowThreads();
13755 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
13756
13757 wxPyEndAllowThreads(__tstate);
13758 if (PyErr_Occurred()) SWIG_fail;
13759 }
13760 Py_INCREF(Py_None); resultobj = Py_None;
13761 return resultobj;
13762 fail:
13763 return NULL;
13764 }
13765
13766
13767 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
13768 PyObject *resultobj;
13769 wxDC *arg1 = (wxDC *) 0 ;
13770 wxString *arg2 = 0 ;
13771 int arg3 ;
13772 int arg4 ;
13773 bool temp2 = false ;
13774 PyObject * obj0 = 0 ;
13775 PyObject * obj1 = 0 ;
13776 PyObject * obj2 = 0 ;
13777 PyObject * obj3 = 0 ;
13778 char *kwnames[] = {
13779 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
13780 };
13781
13782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13784 if (SWIG_arg_fail(1)) SWIG_fail;
13785 {
13786 arg2 = wxString_in_helper(obj1);
13787 if (arg2 == NULL) SWIG_fail;
13788 temp2 = true;
13789 }
13790 {
13791 arg3 = (int)(SWIG_As_int(obj2));
13792 if (SWIG_arg_fail(3)) SWIG_fail;
13793 }
13794 {
13795 arg4 = (int)(SWIG_As_int(obj3));
13796 if (SWIG_arg_fail(4)) SWIG_fail;
13797 }
13798 {
13799 PyThreadState* __tstate = wxPyBeginAllowThreads();
13800 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
13801
13802 wxPyEndAllowThreads(__tstate);
13803 if (PyErr_Occurred()) SWIG_fail;
13804 }
13805 Py_INCREF(Py_None); resultobj = Py_None;
13806 {
13807 if (temp2)
13808 delete arg2;
13809 }
13810 return resultobj;
13811 fail:
13812 {
13813 if (temp2)
13814 delete arg2;
13815 }
13816 return NULL;
13817 }
13818
13819
13820 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13821 PyObject *resultobj;
13822 wxDC *arg1 = (wxDC *) 0 ;
13823 wxString *arg2 = 0 ;
13824 wxPoint *arg3 = 0 ;
13825 bool temp2 = false ;
13826 wxPoint temp3 ;
13827 PyObject * obj0 = 0 ;
13828 PyObject * obj1 = 0 ;
13829 PyObject * obj2 = 0 ;
13830 char *kwnames[] = {
13831 (char *) "self",(char *) "text",(char *) "pt", NULL
13832 };
13833
13834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13836 if (SWIG_arg_fail(1)) SWIG_fail;
13837 {
13838 arg2 = wxString_in_helper(obj1);
13839 if (arg2 == NULL) SWIG_fail;
13840 temp2 = true;
13841 }
13842 {
13843 arg3 = &temp3;
13844 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13845 }
13846 {
13847 PyThreadState* __tstate = wxPyBeginAllowThreads();
13848 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
13849
13850 wxPyEndAllowThreads(__tstate);
13851 if (PyErr_Occurred()) SWIG_fail;
13852 }
13853 Py_INCREF(Py_None); resultobj = Py_None;
13854 {
13855 if (temp2)
13856 delete arg2;
13857 }
13858 return resultobj;
13859 fail:
13860 {
13861 if (temp2)
13862 delete arg2;
13863 }
13864 return NULL;
13865 }
13866
13867
13868 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
13869 PyObject *resultobj;
13870 wxDC *arg1 = (wxDC *) 0 ;
13871 wxString *arg2 = 0 ;
13872 int arg3 ;
13873 int arg4 ;
13874 double arg5 ;
13875 bool temp2 = false ;
13876 PyObject * obj0 = 0 ;
13877 PyObject * obj1 = 0 ;
13878 PyObject * obj2 = 0 ;
13879 PyObject * obj3 = 0 ;
13880 PyObject * obj4 = 0 ;
13881 char *kwnames[] = {
13882 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
13883 };
13884
13885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13887 if (SWIG_arg_fail(1)) SWIG_fail;
13888 {
13889 arg2 = wxString_in_helper(obj1);
13890 if (arg2 == NULL) SWIG_fail;
13891 temp2 = true;
13892 }
13893 {
13894 arg3 = (int)(SWIG_As_int(obj2));
13895 if (SWIG_arg_fail(3)) SWIG_fail;
13896 }
13897 {
13898 arg4 = (int)(SWIG_As_int(obj3));
13899 if (SWIG_arg_fail(4)) SWIG_fail;
13900 }
13901 {
13902 arg5 = (double)(SWIG_As_double(obj4));
13903 if (SWIG_arg_fail(5)) SWIG_fail;
13904 }
13905 {
13906 PyThreadState* __tstate = wxPyBeginAllowThreads();
13907 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
13908
13909 wxPyEndAllowThreads(__tstate);
13910 if (PyErr_Occurred()) SWIG_fail;
13911 }
13912 Py_INCREF(Py_None); resultobj = Py_None;
13913 {
13914 if (temp2)
13915 delete arg2;
13916 }
13917 return resultobj;
13918 fail:
13919 {
13920 if (temp2)
13921 delete arg2;
13922 }
13923 return NULL;
13924 }
13925
13926
13927 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13928 PyObject *resultobj;
13929 wxDC *arg1 = (wxDC *) 0 ;
13930 wxString *arg2 = 0 ;
13931 wxPoint *arg3 = 0 ;
13932 double arg4 ;
13933 bool temp2 = false ;
13934 wxPoint temp3 ;
13935 PyObject * obj0 = 0 ;
13936 PyObject * obj1 = 0 ;
13937 PyObject * obj2 = 0 ;
13938 PyObject * obj3 = 0 ;
13939 char *kwnames[] = {
13940 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
13941 };
13942
13943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13945 if (SWIG_arg_fail(1)) SWIG_fail;
13946 {
13947 arg2 = wxString_in_helper(obj1);
13948 if (arg2 == NULL) SWIG_fail;
13949 temp2 = true;
13950 }
13951 {
13952 arg3 = &temp3;
13953 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13954 }
13955 {
13956 arg4 = (double)(SWIG_As_double(obj3));
13957 if (SWIG_arg_fail(4)) SWIG_fail;
13958 }
13959 {
13960 PyThreadState* __tstate = wxPyBeginAllowThreads();
13961 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
13962
13963 wxPyEndAllowThreads(__tstate);
13964 if (PyErr_Occurred()) SWIG_fail;
13965 }
13966 Py_INCREF(Py_None); resultobj = Py_None;
13967 {
13968 if (temp2)
13969 delete arg2;
13970 }
13971 return resultobj;
13972 fail:
13973 {
13974 if (temp2)
13975 delete arg2;
13976 }
13977 return NULL;
13978 }
13979
13980
13981 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
13982 PyObject *resultobj;
13983 wxDC *arg1 = (wxDC *) 0 ;
13984 int arg2 ;
13985 int arg3 ;
13986 int arg4 ;
13987 int arg5 ;
13988 wxDC *arg6 = (wxDC *) 0 ;
13989 int arg7 ;
13990 int arg8 ;
13991 int arg9 = (int) wxCOPY ;
13992 bool arg10 = (bool) false ;
13993 int arg11 = (int) -1 ;
13994 int arg12 = (int) -1 ;
13995 bool result;
13996 PyObject * obj0 = 0 ;
13997 PyObject * obj1 = 0 ;
13998 PyObject * obj2 = 0 ;
13999 PyObject * obj3 = 0 ;
14000 PyObject * obj4 = 0 ;
14001 PyObject * obj5 = 0 ;
14002 PyObject * obj6 = 0 ;
14003 PyObject * obj7 = 0 ;
14004 PyObject * obj8 = 0 ;
14005 PyObject * obj9 = 0 ;
14006 PyObject * obj10 = 0 ;
14007 PyObject * obj11 = 0 ;
14008 char *kwnames[] = {
14009 (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
14010 };
14011
14012 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;
14013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14014 if (SWIG_arg_fail(1)) SWIG_fail;
14015 {
14016 arg2 = (int)(SWIG_As_int(obj1));
14017 if (SWIG_arg_fail(2)) SWIG_fail;
14018 }
14019 {
14020 arg3 = (int)(SWIG_As_int(obj2));
14021 if (SWIG_arg_fail(3)) SWIG_fail;
14022 }
14023 {
14024 arg4 = (int)(SWIG_As_int(obj3));
14025 if (SWIG_arg_fail(4)) SWIG_fail;
14026 }
14027 {
14028 arg5 = (int)(SWIG_As_int(obj4));
14029 if (SWIG_arg_fail(5)) SWIG_fail;
14030 }
14031 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14032 if (SWIG_arg_fail(6)) SWIG_fail;
14033 {
14034 arg7 = (int)(SWIG_As_int(obj6));
14035 if (SWIG_arg_fail(7)) SWIG_fail;
14036 }
14037 {
14038 arg8 = (int)(SWIG_As_int(obj7));
14039 if (SWIG_arg_fail(8)) SWIG_fail;
14040 }
14041 if (obj8) {
14042 {
14043 arg9 = (int)(SWIG_As_int(obj8));
14044 if (SWIG_arg_fail(9)) SWIG_fail;
14045 }
14046 }
14047 if (obj9) {
14048 {
14049 arg10 = (bool)(SWIG_As_bool(obj9));
14050 if (SWIG_arg_fail(10)) SWIG_fail;
14051 }
14052 }
14053 if (obj10) {
14054 {
14055 arg11 = (int)(SWIG_As_int(obj10));
14056 if (SWIG_arg_fail(11)) SWIG_fail;
14057 }
14058 }
14059 if (obj11) {
14060 {
14061 arg12 = (int)(SWIG_As_int(obj11));
14062 if (SWIG_arg_fail(12)) SWIG_fail;
14063 }
14064 }
14065 {
14066 PyThreadState* __tstate = wxPyBeginAllowThreads();
14067 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14068
14069 wxPyEndAllowThreads(__tstate);
14070 if (PyErr_Occurred()) SWIG_fail;
14071 }
14072 {
14073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14074 }
14075 return resultobj;
14076 fail:
14077 return NULL;
14078 }
14079
14080
14081 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14082 PyObject *resultobj;
14083 wxDC *arg1 = (wxDC *) 0 ;
14084 wxPoint *arg2 = 0 ;
14085 wxSize *arg3 = 0 ;
14086 wxDC *arg4 = (wxDC *) 0 ;
14087 wxPoint *arg5 = 0 ;
14088 int arg6 = (int) wxCOPY ;
14089 bool arg7 = (bool) false ;
14090 wxPoint const &arg8_defvalue = wxDefaultPosition ;
14091 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
14092 bool result;
14093 wxPoint temp2 ;
14094 wxSize temp3 ;
14095 wxPoint temp5 ;
14096 wxPoint temp8 ;
14097 PyObject * obj0 = 0 ;
14098 PyObject * obj1 = 0 ;
14099 PyObject * obj2 = 0 ;
14100 PyObject * obj3 = 0 ;
14101 PyObject * obj4 = 0 ;
14102 PyObject * obj5 = 0 ;
14103 PyObject * obj6 = 0 ;
14104 PyObject * obj7 = 0 ;
14105 char *kwnames[] = {
14106 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
14107 };
14108
14109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
14110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14111 if (SWIG_arg_fail(1)) SWIG_fail;
14112 {
14113 arg2 = &temp2;
14114 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14115 }
14116 {
14117 arg3 = &temp3;
14118 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14119 }
14120 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14121 if (SWIG_arg_fail(4)) SWIG_fail;
14122 {
14123 arg5 = &temp5;
14124 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14125 }
14126 if (obj5) {
14127 {
14128 arg6 = (int)(SWIG_As_int(obj5));
14129 if (SWIG_arg_fail(6)) SWIG_fail;
14130 }
14131 }
14132 if (obj6) {
14133 {
14134 arg7 = (bool)(SWIG_As_bool(obj6));
14135 if (SWIG_arg_fail(7)) SWIG_fail;
14136 }
14137 }
14138 if (obj7) {
14139 {
14140 arg8 = &temp8;
14141 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14142 }
14143 }
14144 {
14145 PyThreadState* __tstate = wxPyBeginAllowThreads();
14146 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14147
14148 wxPyEndAllowThreads(__tstate);
14149 if (PyErr_Occurred()) SWIG_fail;
14150 }
14151 {
14152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14153 }
14154 return resultobj;
14155 fail:
14156 return NULL;
14157 }
14158
14159
14160 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14161 PyObject *resultobj;
14162 wxDC *arg1 = (wxDC *) 0 ;
14163 int arg2 ;
14164 int arg3 ;
14165 int arg4 ;
14166 int arg5 ;
14167 PyObject * obj0 = 0 ;
14168 PyObject * obj1 = 0 ;
14169 PyObject * obj2 = 0 ;
14170 PyObject * obj3 = 0 ;
14171 PyObject * obj4 = 0 ;
14172 char *kwnames[] = {
14173 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14174 };
14175
14176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14178 if (SWIG_arg_fail(1)) SWIG_fail;
14179 {
14180 arg2 = (int)(SWIG_As_int(obj1));
14181 if (SWIG_arg_fail(2)) SWIG_fail;
14182 }
14183 {
14184 arg3 = (int)(SWIG_As_int(obj2));
14185 if (SWIG_arg_fail(3)) SWIG_fail;
14186 }
14187 {
14188 arg4 = (int)(SWIG_As_int(obj3));
14189 if (SWIG_arg_fail(4)) SWIG_fail;
14190 }
14191 {
14192 arg5 = (int)(SWIG_As_int(obj4));
14193 if (SWIG_arg_fail(5)) SWIG_fail;
14194 }
14195 {
14196 PyThreadState* __tstate = wxPyBeginAllowThreads();
14197 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14198
14199 wxPyEndAllowThreads(__tstate);
14200 if (PyErr_Occurred()) SWIG_fail;
14201 }
14202 Py_INCREF(Py_None); resultobj = Py_None;
14203 return resultobj;
14204 fail:
14205 return NULL;
14206 }
14207
14208
14209 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14210 PyObject *resultobj;
14211 wxDC *arg1 = (wxDC *) 0 ;
14212 wxPoint *arg2 = 0 ;
14213 wxSize *arg3 = 0 ;
14214 wxPoint temp2 ;
14215 wxSize temp3 ;
14216 PyObject * obj0 = 0 ;
14217 PyObject * obj1 = 0 ;
14218 PyObject * obj2 = 0 ;
14219 char *kwnames[] = {
14220 (char *) "self",(char *) "pt",(char *) "sz", NULL
14221 };
14222
14223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14225 if (SWIG_arg_fail(1)) SWIG_fail;
14226 {
14227 arg2 = &temp2;
14228 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14229 }
14230 {
14231 arg3 = &temp3;
14232 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14233 }
14234 {
14235 PyThreadState* __tstate = wxPyBeginAllowThreads();
14236 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14237
14238 wxPyEndAllowThreads(__tstate);
14239 if (PyErr_Occurred()) SWIG_fail;
14240 }
14241 Py_INCREF(Py_None); resultobj = Py_None;
14242 return resultobj;
14243 fail:
14244 return NULL;
14245 }
14246
14247
14248 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14249 PyObject *resultobj;
14250 wxDC *arg1 = (wxDC *) 0 ;
14251 wxRegion *arg2 = 0 ;
14252 PyObject * obj0 = 0 ;
14253 PyObject * obj1 = 0 ;
14254 char *kwnames[] = {
14255 (char *) "self",(char *) "region", NULL
14256 };
14257
14258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14260 if (SWIG_arg_fail(1)) SWIG_fail;
14261 {
14262 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14263 if (SWIG_arg_fail(2)) SWIG_fail;
14264 if (arg2 == NULL) {
14265 SWIG_null_ref("wxRegion");
14266 }
14267 if (SWIG_arg_fail(2)) SWIG_fail;
14268 }
14269 {
14270 PyThreadState* __tstate = wxPyBeginAllowThreads();
14271 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14272
14273 wxPyEndAllowThreads(__tstate);
14274 if (PyErr_Occurred()) SWIG_fail;
14275 }
14276 Py_INCREF(Py_None); resultobj = Py_None;
14277 return resultobj;
14278 fail:
14279 return NULL;
14280 }
14281
14282
14283 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14284 PyObject *resultobj;
14285 wxDC *arg1 = (wxDC *) 0 ;
14286 wxRect *arg2 = 0 ;
14287 wxRect temp2 ;
14288 PyObject * obj0 = 0 ;
14289 PyObject * obj1 = 0 ;
14290 char *kwnames[] = {
14291 (char *) "self",(char *) "rect", NULL
14292 };
14293
14294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14296 if (SWIG_arg_fail(1)) SWIG_fail;
14297 {
14298 arg2 = &temp2;
14299 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14300 }
14301 {
14302 PyThreadState* __tstate = wxPyBeginAllowThreads();
14303 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14304
14305 wxPyEndAllowThreads(__tstate);
14306 if (PyErr_Occurred()) SWIG_fail;
14307 }
14308 Py_INCREF(Py_None); resultobj = Py_None;
14309 return resultobj;
14310 fail:
14311 return NULL;
14312 }
14313
14314
14315 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14316 PyObject *resultobj;
14317 wxDC *arg1 = (wxDC *) 0 ;
14318 int arg2 ;
14319 wxPoint *arg3 = (wxPoint *) 0 ;
14320 int arg4 = (int) 0 ;
14321 int arg5 = (int) 0 ;
14322 PyObject * obj0 = 0 ;
14323 PyObject * obj1 = 0 ;
14324 PyObject * obj2 = 0 ;
14325 PyObject * obj3 = 0 ;
14326 char *kwnames[] = {
14327 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14328 };
14329
14330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14332 if (SWIG_arg_fail(1)) SWIG_fail;
14333 {
14334 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14335 if (arg3 == NULL) SWIG_fail;
14336 }
14337 if (obj2) {
14338 {
14339 arg4 = (int)(SWIG_As_int(obj2));
14340 if (SWIG_arg_fail(4)) SWIG_fail;
14341 }
14342 }
14343 if (obj3) {
14344 {
14345 arg5 = (int)(SWIG_As_int(obj3));
14346 if (SWIG_arg_fail(5)) SWIG_fail;
14347 }
14348 }
14349 {
14350 PyThreadState* __tstate = wxPyBeginAllowThreads();
14351 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14352
14353 wxPyEndAllowThreads(__tstate);
14354 if (PyErr_Occurred()) SWIG_fail;
14355 }
14356 Py_INCREF(Py_None); resultobj = Py_None;
14357 {
14358 if (arg3) delete [] arg3;
14359 }
14360 return resultobj;
14361 fail:
14362 {
14363 if (arg3) delete [] arg3;
14364 }
14365 return NULL;
14366 }
14367
14368
14369 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14370 PyObject *resultobj;
14371 wxDC *arg1 = (wxDC *) 0 ;
14372 int arg2 ;
14373 wxPoint *arg3 = (wxPoint *) 0 ;
14374 int arg4 = (int) 0 ;
14375 int arg5 = (int) 0 ;
14376 int arg6 = (int) wxODDEVEN_RULE ;
14377 PyObject * obj0 = 0 ;
14378 PyObject * obj1 = 0 ;
14379 PyObject * obj2 = 0 ;
14380 PyObject * obj3 = 0 ;
14381 PyObject * obj4 = 0 ;
14382 char *kwnames[] = {
14383 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14384 };
14385
14386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14388 if (SWIG_arg_fail(1)) SWIG_fail;
14389 {
14390 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14391 if (arg3 == NULL) SWIG_fail;
14392 }
14393 if (obj2) {
14394 {
14395 arg4 = (int)(SWIG_As_int(obj2));
14396 if (SWIG_arg_fail(4)) SWIG_fail;
14397 }
14398 }
14399 if (obj3) {
14400 {
14401 arg5 = (int)(SWIG_As_int(obj3));
14402 if (SWIG_arg_fail(5)) SWIG_fail;
14403 }
14404 }
14405 if (obj4) {
14406 {
14407 arg6 = (int)(SWIG_As_int(obj4));
14408 if (SWIG_arg_fail(6)) SWIG_fail;
14409 }
14410 }
14411 {
14412 PyThreadState* __tstate = wxPyBeginAllowThreads();
14413 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14414
14415 wxPyEndAllowThreads(__tstate);
14416 if (PyErr_Occurred()) SWIG_fail;
14417 }
14418 Py_INCREF(Py_None); resultobj = Py_None;
14419 {
14420 if (arg3) delete [] arg3;
14421 }
14422 return resultobj;
14423 fail:
14424 {
14425 if (arg3) delete [] arg3;
14426 }
14427 return NULL;
14428 }
14429
14430
14431 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14432 PyObject *resultobj;
14433 wxDC *arg1 = (wxDC *) 0 ;
14434 wxString *arg2 = 0 ;
14435 wxRect *arg3 = 0 ;
14436 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14437 int arg5 = (int) -1 ;
14438 bool temp2 = false ;
14439 wxRect temp3 ;
14440 PyObject * obj0 = 0 ;
14441 PyObject * obj1 = 0 ;
14442 PyObject * obj2 = 0 ;
14443 PyObject * obj3 = 0 ;
14444 PyObject * obj4 = 0 ;
14445 char *kwnames[] = {
14446 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14447 };
14448
14449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14451 if (SWIG_arg_fail(1)) SWIG_fail;
14452 {
14453 arg2 = wxString_in_helper(obj1);
14454 if (arg2 == NULL) SWIG_fail;
14455 temp2 = true;
14456 }
14457 {
14458 arg3 = &temp3;
14459 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
14460 }
14461 if (obj3) {
14462 {
14463 arg4 = (int)(SWIG_As_int(obj3));
14464 if (SWIG_arg_fail(4)) SWIG_fail;
14465 }
14466 }
14467 if (obj4) {
14468 {
14469 arg5 = (int)(SWIG_As_int(obj4));
14470 if (SWIG_arg_fail(5)) SWIG_fail;
14471 }
14472 }
14473 {
14474 PyThreadState* __tstate = wxPyBeginAllowThreads();
14475 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
14476
14477 wxPyEndAllowThreads(__tstate);
14478 if (PyErr_Occurred()) SWIG_fail;
14479 }
14480 Py_INCREF(Py_None); resultobj = Py_None;
14481 {
14482 if (temp2)
14483 delete arg2;
14484 }
14485 return resultobj;
14486 fail:
14487 {
14488 if (temp2)
14489 delete arg2;
14490 }
14491 return NULL;
14492 }
14493
14494
14495 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14496 PyObject *resultobj;
14497 wxDC *arg1 = (wxDC *) 0 ;
14498 wxString *arg2 = 0 ;
14499 wxBitmap *arg3 = 0 ;
14500 wxRect *arg4 = 0 ;
14501 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14502 int arg6 = (int) -1 ;
14503 wxRect result;
14504 bool temp2 = false ;
14505 wxRect temp4 ;
14506 PyObject * obj0 = 0 ;
14507 PyObject * obj1 = 0 ;
14508 PyObject * obj2 = 0 ;
14509 PyObject * obj3 = 0 ;
14510 PyObject * obj4 = 0 ;
14511 PyObject * obj5 = 0 ;
14512 char *kwnames[] = {
14513 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14514 };
14515
14516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14518 if (SWIG_arg_fail(1)) SWIG_fail;
14519 {
14520 arg2 = wxString_in_helper(obj1);
14521 if (arg2 == NULL) SWIG_fail;
14522 temp2 = true;
14523 }
14524 {
14525 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14526 if (SWIG_arg_fail(3)) SWIG_fail;
14527 if (arg3 == NULL) {
14528 SWIG_null_ref("wxBitmap");
14529 }
14530 if (SWIG_arg_fail(3)) SWIG_fail;
14531 }
14532 {
14533 arg4 = &temp4;
14534 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
14535 }
14536 if (obj4) {
14537 {
14538 arg5 = (int)(SWIG_As_int(obj4));
14539 if (SWIG_arg_fail(5)) SWIG_fail;
14540 }
14541 }
14542 if (obj5) {
14543 {
14544 arg6 = (int)(SWIG_As_int(obj5));
14545 if (SWIG_arg_fail(6)) SWIG_fail;
14546 }
14547 }
14548 {
14549 PyThreadState* __tstate = wxPyBeginAllowThreads();
14550 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
14551
14552 wxPyEndAllowThreads(__tstate);
14553 if (PyErr_Occurred()) SWIG_fail;
14554 }
14555 {
14556 wxRect * resultptr;
14557 resultptr = new wxRect((wxRect &)(result));
14558 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14559 }
14560 {
14561 if (temp2)
14562 delete arg2;
14563 }
14564 return resultobj;
14565 fail:
14566 {
14567 if (temp2)
14568 delete arg2;
14569 }
14570 return NULL;
14571 }
14572
14573
14574 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
14575 PyObject *resultobj;
14576 wxDC *arg1 = (wxDC *) 0 ;
14577 int arg2 ;
14578 wxPoint *arg3 = (wxPoint *) 0 ;
14579 PyObject * obj0 = 0 ;
14580 PyObject * obj1 = 0 ;
14581 char *kwnames[] = {
14582 (char *) "self",(char *) "points", NULL
14583 };
14584
14585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
14586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14587 if (SWIG_arg_fail(1)) SWIG_fail;
14588 {
14589 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14590 if (arg3 == NULL) SWIG_fail;
14591 }
14592 {
14593 PyThreadState* __tstate = wxPyBeginAllowThreads();
14594 (arg1)->DrawSpline(arg2,arg3);
14595
14596 wxPyEndAllowThreads(__tstate);
14597 if (PyErr_Occurred()) SWIG_fail;
14598 }
14599 Py_INCREF(Py_None); resultobj = Py_None;
14600 {
14601 if (arg3) delete [] arg3;
14602 }
14603 return resultobj;
14604 fail:
14605 {
14606 if (arg3) delete [] arg3;
14607 }
14608 return NULL;
14609 }
14610
14611
14612 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
14613 PyObject *resultobj;
14614 wxDC *arg1 = (wxDC *) 0 ;
14615 PyObject * obj0 = 0 ;
14616 char *kwnames[] = {
14617 (char *) "self", NULL
14618 };
14619
14620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
14621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14622 if (SWIG_arg_fail(1)) SWIG_fail;
14623 {
14624 PyThreadState* __tstate = wxPyBeginAllowThreads();
14625 (arg1)->Clear();
14626
14627 wxPyEndAllowThreads(__tstate);
14628 if (PyErr_Occurred()) SWIG_fail;
14629 }
14630 Py_INCREF(Py_None); resultobj = Py_None;
14631 return resultobj;
14632 fail:
14633 return NULL;
14634 }
14635
14636
14637 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14638 PyObject *resultobj;
14639 wxDC *arg1 = (wxDC *) 0 ;
14640 wxString *arg2 = 0 ;
14641 bool result;
14642 bool temp2 = false ;
14643 PyObject * obj0 = 0 ;
14644 PyObject * obj1 = 0 ;
14645 char *kwnames[] = {
14646 (char *) "self",(char *) "message", NULL
14647 };
14648
14649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
14650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14651 if (SWIG_arg_fail(1)) SWIG_fail;
14652 {
14653 arg2 = wxString_in_helper(obj1);
14654 if (arg2 == NULL) SWIG_fail;
14655 temp2 = true;
14656 }
14657 {
14658 PyThreadState* __tstate = wxPyBeginAllowThreads();
14659 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
14660
14661 wxPyEndAllowThreads(__tstate);
14662 if (PyErr_Occurred()) SWIG_fail;
14663 }
14664 {
14665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14666 }
14667 {
14668 if (temp2)
14669 delete arg2;
14670 }
14671 return resultobj;
14672 fail:
14673 {
14674 if (temp2)
14675 delete arg2;
14676 }
14677 return NULL;
14678 }
14679
14680
14681 static PyObject *_wrap_DC_EndDoc(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_EndDoc",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)->EndDoc();
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_StartPage(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_StartPage",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)->StartPage();
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_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
14732 PyObject *resultobj;
14733 wxDC *arg1 = (wxDC *) 0 ;
14734 PyObject * obj0 = 0 ;
14735 char *kwnames[] = {
14736 (char *) "self", NULL
14737 };
14738
14739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
14740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14741 if (SWIG_arg_fail(1)) SWIG_fail;
14742 {
14743 PyThreadState* __tstate = wxPyBeginAllowThreads();
14744 (arg1)->EndPage();
14745
14746 wxPyEndAllowThreads(__tstate);
14747 if (PyErr_Occurred()) SWIG_fail;
14748 }
14749 Py_INCREF(Py_None); resultobj = Py_None;
14750 return resultobj;
14751 fail:
14752 return NULL;
14753 }
14754
14755
14756 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
14757 PyObject *resultobj;
14758 wxDC *arg1 = (wxDC *) 0 ;
14759 wxFont *arg2 = 0 ;
14760 PyObject * obj0 = 0 ;
14761 PyObject * obj1 = 0 ;
14762 char *kwnames[] = {
14763 (char *) "self",(char *) "font", NULL
14764 };
14765
14766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
14767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14768 if (SWIG_arg_fail(1)) SWIG_fail;
14769 {
14770 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14771 if (SWIG_arg_fail(2)) SWIG_fail;
14772 if (arg2 == NULL) {
14773 SWIG_null_ref("wxFont");
14774 }
14775 if (SWIG_arg_fail(2)) SWIG_fail;
14776 }
14777 {
14778 PyThreadState* __tstate = wxPyBeginAllowThreads();
14779 (arg1)->SetFont((wxFont const &)*arg2);
14780
14781 wxPyEndAllowThreads(__tstate);
14782 if (PyErr_Occurred()) SWIG_fail;
14783 }
14784 Py_INCREF(Py_None); resultobj = Py_None;
14785 return resultobj;
14786 fail:
14787 return NULL;
14788 }
14789
14790
14791 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
14792 PyObject *resultobj;
14793 wxDC *arg1 = (wxDC *) 0 ;
14794 wxPen *arg2 = 0 ;
14795 PyObject * obj0 = 0 ;
14796 PyObject * obj1 = 0 ;
14797 char *kwnames[] = {
14798 (char *) "self",(char *) "pen", NULL
14799 };
14800
14801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
14802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14803 if (SWIG_arg_fail(1)) SWIG_fail;
14804 {
14805 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
14806 if (SWIG_arg_fail(2)) SWIG_fail;
14807 if (arg2 == NULL) {
14808 SWIG_null_ref("wxPen");
14809 }
14810 if (SWIG_arg_fail(2)) SWIG_fail;
14811 }
14812 {
14813 PyThreadState* __tstate = wxPyBeginAllowThreads();
14814 (arg1)->SetPen((wxPen const &)*arg2);
14815
14816 wxPyEndAllowThreads(__tstate);
14817 if (PyErr_Occurred()) SWIG_fail;
14818 }
14819 Py_INCREF(Py_None); resultobj = Py_None;
14820 return resultobj;
14821 fail:
14822 return NULL;
14823 }
14824
14825
14826 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
14827 PyObject *resultobj;
14828 wxDC *arg1 = (wxDC *) 0 ;
14829 wxBrush *arg2 = 0 ;
14830 PyObject * obj0 = 0 ;
14831 PyObject * obj1 = 0 ;
14832 char *kwnames[] = {
14833 (char *) "self",(char *) "brush", NULL
14834 };
14835
14836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
14837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14838 if (SWIG_arg_fail(1)) SWIG_fail;
14839 {
14840 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14841 if (SWIG_arg_fail(2)) SWIG_fail;
14842 if (arg2 == NULL) {
14843 SWIG_null_ref("wxBrush");
14844 }
14845 if (SWIG_arg_fail(2)) SWIG_fail;
14846 }
14847 {
14848 PyThreadState* __tstate = wxPyBeginAllowThreads();
14849 (arg1)->SetBrush((wxBrush const &)*arg2);
14850
14851 wxPyEndAllowThreads(__tstate);
14852 if (PyErr_Occurred()) SWIG_fail;
14853 }
14854 Py_INCREF(Py_None); resultobj = Py_None;
14855 return resultobj;
14856 fail:
14857 return NULL;
14858 }
14859
14860
14861 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
14862 PyObject *resultobj;
14863 wxDC *arg1 = (wxDC *) 0 ;
14864 wxBrush *arg2 = 0 ;
14865 PyObject * obj0 = 0 ;
14866 PyObject * obj1 = 0 ;
14867 char *kwnames[] = {
14868 (char *) "self",(char *) "brush", NULL
14869 };
14870
14871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
14872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14873 if (SWIG_arg_fail(1)) SWIG_fail;
14874 {
14875 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14876 if (SWIG_arg_fail(2)) SWIG_fail;
14877 if (arg2 == NULL) {
14878 SWIG_null_ref("wxBrush");
14879 }
14880 if (SWIG_arg_fail(2)) SWIG_fail;
14881 }
14882 {
14883 PyThreadState* __tstate = wxPyBeginAllowThreads();
14884 (arg1)->SetBackground((wxBrush const &)*arg2);
14885
14886 wxPyEndAllowThreads(__tstate);
14887 if (PyErr_Occurred()) SWIG_fail;
14888 }
14889 Py_INCREF(Py_None); resultobj = Py_None;
14890 return resultobj;
14891 fail:
14892 return NULL;
14893 }
14894
14895
14896 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
14897 PyObject *resultobj;
14898 wxDC *arg1 = (wxDC *) 0 ;
14899 int arg2 ;
14900 PyObject * obj0 = 0 ;
14901 PyObject * obj1 = 0 ;
14902 char *kwnames[] = {
14903 (char *) "self",(char *) "mode", NULL
14904 };
14905
14906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
14907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14908 if (SWIG_arg_fail(1)) SWIG_fail;
14909 {
14910 arg2 = (int)(SWIG_As_int(obj1));
14911 if (SWIG_arg_fail(2)) SWIG_fail;
14912 }
14913 {
14914 PyThreadState* __tstate = wxPyBeginAllowThreads();
14915 (arg1)->SetBackgroundMode(arg2);
14916
14917 wxPyEndAllowThreads(__tstate);
14918 if (PyErr_Occurred()) SWIG_fail;
14919 }
14920 Py_INCREF(Py_None); resultobj = Py_None;
14921 return resultobj;
14922 fail:
14923 return NULL;
14924 }
14925
14926
14927 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
14928 PyObject *resultobj;
14929 wxDC *arg1 = (wxDC *) 0 ;
14930 wxPalette *arg2 = 0 ;
14931 PyObject * obj0 = 0 ;
14932 PyObject * obj1 = 0 ;
14933 char *kwnames[] = {
14934 (char *) "self",(char *) "palette", NULL
14935 };
14936
14937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
14938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14939 if (SWIG_arg_fail(1)) SWIG_fail;
14940 {
14941 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
14942 if (SWIG_arg_fail(2)) SWIG_fail;
14943 if (arg2 == NULL) {
14944 SWIG_null_ref("wxPalette");
14945 }
14946 if (SWIG_arg_fail(2)) SWIG_fail;
14947 }
14948 {
14949 PyThreadState* __tstate = wxPyBeginAllowThreads();
14950 (arg1)->SetPalette((wxPalette const &)*arg2);
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_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14963 PyObject *resultobj;
14964 wxDC *arg1 = (wxDC *) 0 ;
14965 PyObject * obj0 = 0 ;
14966 char *kwnames[] = {
14967 (char *) "self", NULL
14968 };
14969
14970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
14971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14972 if (SWIG_arg_fail(1)) SWIG_fail;
14973 {
14974 PyThreadState* __tstate = wxPyBeginAllowThreads();
14975 (arg1)->DestroyClippingRegion();
14976
14977 wxPyEndAllowThreads(__tstate);
14978 if (PyErr_Occurred()) SWIG_fail;
14979 }
14980 Py_INCREF(Py_None); resultobj = Py_None;
14981 return resultobj;
14982 fail:
14983 return NULL;
14984 }
14985
14986
14987 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
14988 PyObject *resultobj;
14989 wxDC *arg1 = (wxDC *) 0 ;
14990 int *arg2 = (int *) 0 ;
14991 int *arg3 = (int *) 0 ;
14992 int *arg4 = (int *) 0 ;
14993 int *arg5 = (int *) 0 ;
14994 int temp2 ;
14995 int res2 = 0 ;
14996 int temp3 ;
14997 int res3 = 0 ;
14998 int temp4 ;
14999 int res4 = 0 ;
15000 int temp5 ;
15001 int res5 = 0 ;
15002 PyObject * obj0 = 0 ;
15003 char *kwnames[] = {
15004 (char *) "self", NULL
15005 };
15006
15007 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15008 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15009 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15010 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
15012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15013 if (SWIG_arg_fail(1)) SWIG_fail;
15014 {
15015 PyThreadState* __tstate = wxPyBeginAllowThreads();
15016 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
15017
15018 wxPyEndAllowThreads(__tstate);
15019 if (PyErr_Occurred()) SWIG_fail;
15020 }
15021 Py_INCREF(Py_None); resultobj = Py_None;
15022 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15023 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15024 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15025 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15026 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15027 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15028 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15029 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15030 return resultobj;
15031 fail:
15032 return NULL;
15033 }
15034
15035
15036 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
15037 PyObject *resultobj;
15038 wxDC *arg1 = (wxDC *) 0 ;
15039 wxRect result;
15040 PyObject * obj0 = 0 ;
15041 char *kwnames[] = {
15042 (char *) "self", NULL
15043 };
15044
15045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
15046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15047 if (SWIG_arg_fail(1)) SWIG_fail;
15048 {
15049 PyThreadState* __tstate = wxPyBeginAllowThreads();
15050 result = wxDC_GetClippingRect(arg1);
15051
15052 wxPyEndAllowThreads(__tstate);
15053 if (PyErr_Occurred()) SWIG_fail;
15054 }
15055 {
15056 wxRect * resultptr;
15057 resultptr = new wxRect((wxRect &)(result));
15058 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15059 }
15060 return resultobj;
15061 fail:
15062 return NULL;
15063 }
15064
15065
15066 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
15067 PyObject *resultobj;
15068 wxDC *arg1 = (wxDC *) 0 ;
15069 int result;
15070 PyObject * obj0 = 0 ;
15071 char *kwnames[] = {
15072 (char *) "self", NULL
15073 };
15074
15075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
15076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15077 if (SWIG_arg_fail(1)) SWIG_fail;
15078 {
15079 PyThreadState* __tstate = wxPyBeginAllowThreads();
15080 result = (int)((wxDC const *)arg1)->GetCharHeight();
15081
15082 wxPyEndAllowThreads(__tstate);
15083 if (PyErr_Occurred()) SWIG_fail;
15084 }
15085 {
15086 resultobj = SWIG_From_int((int)(result));
15087 }
15088 return resultobj;
15089 fail:
15090 return NULL;
15091 }
15092
15093
15094 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
15095 PyObject *resultobj;
15096 wxDC *arg1 = (wxDC *) 0 ;
15097 int result;
15098 PyObject * obj0 = 0 ;
15099 char *kwnames[] = {
15100 (char *) "self", NULL
15101 };
15102
15103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
15104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15105 if (SWIG_arg_fail(1)) SWIG_fail;
15106 {
15107 PyThreadState* __tstate = wxPyBeginAllowThreads();
15108 result = (int)((wxDC const *)arg1)->GetCharWidth();
15109
15110 wxPyEndAllowThreads(__tstate);
15111 if (PyErr_Occurred()) SWIG_fail;
15112 }
15113 {
15114 resultobj = SWIG_From_int((int)(result));
15115 }
15116 return resultobj;
15117 fail:
15118 return NULL;
15119 }
15120
15121
15122 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15123 PyObject *resultobj;
15124 wxDC *arg1 = (wxDC *) 0 ;
15125 wxString *arg2 = 0 ;
15126 int *arg3 = (int *) 0 ;
15127 int *arg4 = (int *) 0 ;
15128 bool temp2 = false ;
15129 int temp3 ;
15130 int res3 = 0 ;
15131 int temp4 ;
15132 int res4 = 0 ;
15133 PyObject * obj0 = 0 ;
15134 PyObject * obj1 = 0 ;
15135 char *kwnames[] = {
15136 (char *) "self",(char *) "string", NULL
15137 };
15138
15139 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15140 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15143 if (SWIG_arg_fail(1)) SWIG_fail;
15144 {
15145 arg2 = wxString_in_helper(obj1);
15146 if (arg2 == NULL) SWIG_fail;
15147 temp2 = true;
15148 }
15149 {
15150 PyThreadState* __tstate = wxPyBeginAllowThreads();
15151 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15152
15153 wxPyEndAllowThreads(__tstate);
15154 if (PyErr_Occurred()) SWIG_fail;
15155 }
15156 Py_INCREF(Py_None); resultobj = Py_None;
15157 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15158 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15159 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15160 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15161 {
15162 if (temp2)
15163 delete arg2;
15164 }
15165 return resultobj;
15166 fail:
15167 {
15168 if (temp2)
15169 delete arg2;
15170 }
15171 return NULL;
15172 }
15173
15174
15175 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15176 PyObject *resultobj;
15177 wxDC *arg1 = (wxDC *) 0 ;
15178 wxString *arg2 = 0 ;
15179 int *arg3 = (int *) 0 ;
15180 int *arg4 = (int *) 0 ;
15181 int *arg5 = (int *) 0 ;
15182 int *arg6 = (int *) 0 ;
15183 wxFont *arg7 = (wxFont *) NULL ;
15184 bool temp2 = false ;
15185 int temp3 ;
15186 int res3 = 0 ;
15187 int temp4 ;
15188 int res4 = 0 ;
15189 int temp5 ;
15190 int res5 = 0 ;
15191 int temp6 ;
15192 int res6 = 0 ;
15193 PyObject * obj0 = 0 ;
15194 PyObject * obj1 = 0 ;
15195 PyObject * obj2 = 0 ;
15196 char *kwnames[] = {
15197 (char *) "self",(char *) "string",(char *) "font", NULL
15198 };
15199
15200 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15201 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15202 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15203 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15206 if (SWIG_arg_fail(1)) SWIG_fail;
15207 {
15208 arg2 = wxString_in_helper(obj1);
15209 if (arg2 == NULL) SWIG_fail;
15210 temp2 = true;
15211 }
15212 if (obj2) {
15213 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15214 if (SWIG_arg_fail(7)) SWIG_fail;
15215 }
15216 {
15217 PyThreadState* __tstate = wxPyBeginAllowThreads();
15218 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15219
15220 wxPyEndAllowThreads(__tstate);
15221 if (PyErr_Occurred()) SWIG_fail;
15222 }
15223 Py_INCREF(Py_None); resultobj = Py_None;
15224 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15225 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15226 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15227 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15228 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15229 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15230 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15231 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15232 {
15233 if (temp2)
15234 delete arg2;
15235 }
15236 return resultobj;
15237 fail:
15238 {
15239 if (temp2)
15240 delete arg2;
15241 }
15242 return NULL;
15243 }
15244
15245
15246 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15247 PyObject *resultobj;
15248 wxDC *arg1 = (wxDC *) 0 ;
15249 wxString *arg2 = 0 ;
15250 int *arg3 = (int *) 0 ;
15251 int *arg4 = (int *) 0 ;
15252 int *arg5 = (int *) 0 ;
15253 wxFont *arg6 = (wxFont *) NULL ;
15254 bool temp2 = false ;
15255 int temp3 ;
15256 int res3 = 0 ;
15257 int temp4 ;
15258 int res4 = 0 ;
15259 int temp5 ;
15260 int res5 = 0 ;
15261 PyObject * obj0 = 0 ;
15262 PyObject * obj1 = 0 ;
15263 PyObject * obj2 = 0 ;
15264 char *kwnames[] = {
15265 (char *) "self",(char *) "text",(char *) "font", NULL
15266 };
15267
15268 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15269 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15270 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15273 if (SWIG_arg_fail(1)) SWIG_fail;
15274 {
15275 arg2 = wxString_in_helper(obj1);
15276 if (arg2 == NULL) SWIG_fail;
15277 temp2 = true;
15278 }
15279 if (obj2) {
15280 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15281 if (SWIG_arg_fail(6)) SWIG_fail;
15282 }
15283 {
15284 PyThreadState* __tstate = wxPyBeginAllowThreads();
15285 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15286
15287 wxPyEndAllowThreads(__tstate);
15288 if (PyErr_Occurred()) SWIG_fail;
15289 }
15290 Py_INCREF(Py_None); resultobj = Py_None;
15291 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15292 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15293 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15294 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15295 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15296 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15297 {
15298 if (temp2)
15299 delete arg2;
15300 }
15301 return resultobj;
15302 fail:
15303 {
15304 if (temp2)
15305 delete arg2;
15306 }
15307 return NULL;
15308 }
15309
15310
15311 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15312 PyObject *resultobj;
15313 wxDC *arg1 = (wxDC *) 0 ;
15314 wxString *arg2 = 0 ;
15315 wxArrayInt result;
15316 bool temp2 = false ;
15317 PyObject * obj0 = 0 ;
15318 PyObject * obj1 = 0 ;
15319 char *kwnames[] = {
15320 (char *) "self",(char *) "text", NULL
15321 };
15322
15323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15325 if (SWIG_arg_fail(1)) SWIG_fail;
15326 {
15327 arg2 = wxString_in_helper(obj1);
15328 if (arg2 == NULL) SWIG_fail;
15329 temp2 = true;
15330 }
15331 {
15332 PyThreadState* __tstate = wxPyBeginAllowThreads();
15333 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15334
15335 wxPyEndAllowThreads(__tstate);
15336 if (PyErr_Occurred()) SWIG_fail;
15337 }
15338 {
15339 resultobj = PyList_New(0);
15340 size_t idx;
15341 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15342 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15343 PyList_Append(resultobj, val);
15344 Py_DECREF(val);
15345 }
15346 }
15347 {
15348 if (temp2)
15349 delete arg2;
15350 }
15351 return resultobj;
15352 fail:
15353 {
15354 if (temp2)
15355 delete arg2;
15356 }
15357 return NULL;
15358 }
15359
15360
15361 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15362 PyObject *resultobj;
15363 wxDC *arg1 = (wxDC *) 0 ;
15364 wxSize result;
15365 PyObject * obj0 = 0 ;
15366 char *kwnames[] = {
15367 (char *) "self", NULL
15368 };
15369
15370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15372 if (SWIG_arg_fail(1)) SWIG_fail;
15373 {
15374 PyThreadState* __tstate = wxPyBeginAllowThreads();
15375 result = (arg1)->GetSize();
15376
15377 wxPyEndAllowThreads(__tstate);
15378 if (PyErr_Occurred()) SWIG_fail;
15379 }
15380 {
15381 wxSize * resultptr;
15382 resultptr = new wxSize((wxSize &)(result));
15383 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15384 }
15385 return resultobj;
15386 fail:
15387 return NULL;
15388 }
15389
15390
15391 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15392 PyObject *resultobj;
15393 wxDC *arg1 = (wxDC *) 0 ;
15394 int *arg2 = (int *) 0 ;
15395 int *arg3 = (int *) 0 ;
15396 int temp2 ;
15397 int res2 = 0 ;
15398 int temp3 ;
15399 int res3 = 0 ;
15400 PyObject * obj0 = 0 ;
15401 char *kwnames[] = {
15402 (char *) "self", NULL
15403 };
15404
15405 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15406 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15409 if (SWIG_arg_fail(1)) SWIG_fail;
15410 {
15411 PyThreadState* __tstate = wxPyBeginAllowThreads();
15412 (arg1)->GetSize(arg2,arg3);
15413
15414 wxPyEndAllowThreads(__tstate);
15415 if (PyErr_Occurred()) SWIG_fail;
15416 }
15417 Py_INCREF(Py_None); resultobj = Py_None;
15418 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15419 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15420 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15421 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15422 return resultobj;
15423 fail:
15424 return NULL;
15425 }
15426
15427
15428 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15429 PyObject *resultobj;
15430 wxDC *arg1 = (wxDC *) 0 ;
15431 wxSize result;
15432 PyObject * obj0 = 0 ;
15433 char *kwnames[] = {
15434 (char *) "self", NULL
15435 };
15436
15437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
15438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15439 if (SWIG_arg_fail(1)) SWIG_fail;
15440 {
15441 PyThreadState* __tstate = wxPyBeginAllowThreads();
15442 result = ((wxDC const *)arg1)->GetSizeMM();
15443
15444 wxPyEndAllowThreads(__tstate);
15445 if (PyErr_Occurred()) SWIG_fail;
15446 }
15447 {
15448 wxSize * resultptr;
15449 resultptr = new wxSize((wxSize &)(result));
15450 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15451 }
15452 return resultobj;
15453 fail:
15454 return NULL;
15455 }
15456
15457
15458 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15459 PyObject *resultobj;
15460 wxDC *arg1 = (wxDC *) 0 ;
15461 int *arg2 = (int *) 0 ;
15462 int *arg3 = (int *) 0 ;
15463 int temp2 ;
15464 int res2 = 0 ;
15465 int temp3 ;
15466 int res3 = 0 ;
15467 PyObject * obj0 = 0 ;
15468 char *kwnames[] = {
15469 (char *) "self", NULL
15470 };
15471
15472 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15473 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
15475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15476 if (SWIG_arg_fail(1)) SWIG_fail;
15477 {
15478 PyThreadState* __tstate = wxPyBeginAllowThreads();
15479 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
15480
15481 wxPyEndAllowThreads(__tstate);
15482 if (PyErr_Occurred()) SWIG_fail;
15483 }
15484 Py_INCREF(Py_None); resultobj = Py_None;
15485 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15486 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15487 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15488 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15489 return resultobj;
15490 fail:
15491 return NULL;
15492 }
15493
15494
15495 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
15496 PyObject *resultobj;
15497 wxDC *arg1 = (wxDC *) 0 ;
15498 int arg2 ;
15499 int result;
15500 PyObject * obj0 = 0 ;
15501 PyObject * obj1 = 0 ;
15502 char *kwnames[] = {
15503 (char *) "self",(char *) "x", NULL
15504 };
15505
15506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
15507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15508 if (SWIG_arg_fail(1)) SWIG_fail;
15509 {
15510 arg2 = (int)(SWIG_As_int(obj1));
15511 if (SWIG_arg_fail(2)) SWIG_fail;
15512 }
15513 {
15514 PyThreadState* __tstate = wxPyBeginAllowThreads();
15515 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
15516
15517 wxPyEndAllowThreads(__tstate);
15518 if (PyErr_Occurred()) SWIG_fail;
15519 }
15520 {
15521 resultobj = SWIG_From_int((int)(result));
15522 }
15523 return resultobj;
15524 fail:
15525 return NULL;
15526 }
15527
15528
15529 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
15530 PyObject *resultobj;
15531 wxDC *arg1 = (wxDC *) 0 ;
15532 int arg2 ;
15533 int result;
15534 PyObject * obj0 = 0 ;
15535 PyObject * obj1 = 0 ;
15536 char *kwnames[] = {
15537 (char *) "self",(char *) "y", NULL
15538 };
15539
15540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
15541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15542 if (SWIG_arg_fail(1)) SWIG_fail;
15543 {
15544 arg2 = (int)(SWIG_As_int(obj1));
15545 if (SWIG_arg_fail(2)) SWIG_fail;
15546 }
15547 {
15548 PyThreadState* __tstate = wxPyBeginAllowThreads();
15549 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
15550
15551 wxPyEndAllowThreads(__tstate);
15552 if (PyErr_Occurred()) SWIG_fail;
15553 }
15554 {
15555 resultobj = SWIG_From_int((int)(result));
15556 }
15557 return resultobj;
15558 fail:
15559 return NULL;
15560 }
15561
15562
15563 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15564 PyObject *resultobj;
15565 wxDC *arg1 = (wxDC *) 0 ;
15566 int arg2 ;
15567 int result;
15568 PyObject * obj0 = 0 ;
15569 PyObject * obj1 = 0 ;
15570 char *kwnames[] = {
15571 (char *) "self",(char *) "x", NULL
15572 };
15573
15574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
15575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15576 if (SWIG_arg_fail(1)) SWIG_fail;
15577 {
15578 arg2 = (int)(SWIG_As_int(obj1));
15579 if (SWIG_arg_fail(2)) SWIG_fail;
15580 }
15581 {
15582 PyThreadState* __tstate = wxPyBeginAllowThreads();
15583 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
15584
15585 wxPyEndAllowThreads(__tstate);
15586 if (PyErr_Occurred()) SWIG_fail;
15587 }
15588 {
15589 resultobj = SWIG_From_int((int)(result));
15590 }
15591 return resultobj;
15592 fail:
15593 return NULL;
15594 }
15595
15596
15597 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15598 PyObject *resultobj;
15599 wxDC *arg1 = (wxDC *) 0 ;
15600 int arg2 ;
15601 int result;
15602 PyObject * obj0 = 0 ;
15603 PyObject * obj1 = 0 ;
15604 char *kwnames[] = {
15605 (char *) "self",(char *) "y", NULL
15606 };
15607
15608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
15609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15610 if (SWIG_arg_fail(1)) SWIG_fail;
15611 {
15612 arg2 = (int)(SWIG_As_int(obj1));
15613 if (SWIG_arg_fail(2)) SWIG_fail;
15614 }
15615 {
15616 PyThreadState* __tstate = wxPyBeginAllowThreads();
15617 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
15618
15619 wxPyEndAllowThreads(__tstate);
15620 if (PyErr_Occurred()) SWIG_fail;
15621 }
15622 {
15623 resultobj = SWIG_From_int((int)(result));
15624 }
15625 return resultobj;
15626 fail:
15627 return NULL;
15628 }
15629
15630
15631 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
15632 PyObject *resultobj;
15633 wxDC *arg1 = (wxDC *) 0 ;
15634 int arg2 ;
15635 int result;
15636 PyObject * obj0 = 0 ;
15637 PyObject * obj1 = 0 ;
15638 char *kwnames[] = {
15639 (char *) "self",(char *) "x", NULL
15640 };
15641
15642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
15643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15644 if (SWIG_arg_fail(1)) SWIG_fail;
15645 {
15646 arg2 = (int)(SWIG_As_int(obj1));
15647 if (SWIG_arg_fail(2)) SWIG_fail;
15648 }
15649 {
15650 PyThreadState* __tstate = wxPyBeginAllowThreads();
15651 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
15652
15653 wxPyEndAllowThreads(__tstate);
15654 if (PyErr_Occurred()) SWIG_fail;
15655 }
15656 {
15657 resultobj = SWIG_From_int((int)(result));
15658 }
15659 return resultobj;
15660 fail:
15661 return NULL;
15662 }
15663
15664
15665 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
15666 PyObject *resultobj;
15667 wxDC *arg1 = (wxDC *) 0 ;
15668 int arg2 ;
15669 int result;
15670 PyObject * obj0 = 0 ;
15671 PyObject * obj1 = 0 ;
15672 char *kwnames[] = {
15673 (char *) "self",(char *) "y", NULL
15674 };
15675
15676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
15677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15678 if (SWIG_arg_fail(1)) SWIG_fail;
15679 {
15680 arg2 = (int)(SWIG_As_int(obj1));
15681 if (SWIG_arg_fail(2)) SWIG_fail;
15682 }
15683 {
15684 PyThreadState* __tstate = wxPyBeginAllowThreads();
15685 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
15686
15687 wxPyEndAllowThreads(__tstate);
15688 if (PyErr_Occurred()) SWIG_fail;
15689 }
15690 {
15691 resultobj = SWIG_From_int((int)(result));
15692 }
15693 return resultobj;
15694 fail:
15695 return NULL;
15696 }
15697
15698
15699 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15700 PyObject *resultobj;
15701 wxDC *arg1 = (wxDC *) 0 ;
15702 int arg2 ;
15703 int result;
15704 PyObject * obj0 = 0 ;
15705 PyObject * obj1 = 0 ;
15706 char *kwnames[] = {
15707 (char *) "self",(char *) "x", NULL
15708 };
15709
15710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
15711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15712 if (SWIG_arg_fail(1)) SWIG_fail;
15713 {
15714 arg2 = (int)(SWIG_As_int(obj1));
15715 if (SWIG_arg_fail(2)) SWIG_fail;
15716 }
15717 {
15718 PyThreadState* __tstate = wxPyBeginAllowThreads();
15719 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
15720
15721 wxPyEndAllowThreads(__tstate);
15722 if (PyErr_Occurred()) SWIG_fail;
15723 }
15724 {
15725 resultobj = SWIG_From_int((int)(result));
15726 }
15727 return resultobj;
15728 fail:
15729 return NULL;
15730 }
15731
15732
15733 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15734 PyObject *resultobj;
15735 wxDC *arg1 = (wxDC *) 0 ;
15736 int arg2 ;
15737 int result;
15738 PyObject * obj0 = 0 ;
15739 PyObject * obj1 = 0 ;
15740 char *kwnames[] = {
15741 (char *) "self",(char *) "y", NULL
15742 };
15743
15744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
15745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15746 if (SWIG_arg_fail(1)) SWIG_fail;
15747 {
15748 arg2 = (int)(SWIG_As_int(obj1));
15749 if (SWIG_arg_fail(2)) SWIG_fail;
15750 }
15751 {
15752 PyThreadState* __tstate = wxPyBeginAllowThreads();
15753 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
15754
15755 wxPyEndAllowThreads(__tstate);
15756 if (PyErr_Occurred()) SWIG_fail;
15757 }
15758 {
15759 resultobj = SWIG_From_int((int)(result));
15760 }
15761 return resultobj;
15762 fail:
15763 return NULL;
15764 }
15765
15766
15767 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
15768 PyObject *resultobj;
15769 wxDC *arg1 = (wxDC *) 0 ;
15770 bool result;
15771 PyObject * obj0 = 0 ;
15772 char *kwnames[] = {
15773 (char *) "self", NULL
15774 };
15775
15776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
15777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15778 if (SWIG_arg_fail(1)) SWIG_fail;
15779 {
15780 PyThreadState* __tstate = wxPyBeginAllowThreads();
15781 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
15782
15783 wxPyEndAllowThreads(__tstate);
15784 if (PyErr_Occurred()) SWIG_fail;
15785 }
15786 {
15787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15788 }
15789 return resultobj;
15790 fail:
15791 return NULL;
15792 }
15793
15794
15795 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15796 PyObject *resultobj;
15797 wxDC *arg1 = (wxDC *) 0 ;
15798 bool result;
15799 PyObject * obj0 = 0 ;
15800 char *kwnames[] = {
15801 (char *) "self", NULL
15802 };
15803
15804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
15805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15806 if (SWIG_arg_fail(1)) SWIG_fail;
15807 {
15808 PyThreadState* __tstate = wxPyBeginAllowThreads();
15809 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
15810
15811 wxPyEndAllowThreads(__tstate);
15812 if (PyErr_Occurred()) SWIG_fail;
15813 }
15814 {
15815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15816 }
15817 return resultobj;
15818 fail:
15819 return NULL;
15820 }
15821
15822
15823 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
15824 PyObject *resultobj;
15825 wxDC *arg1 = (wxDC *) 0 ;
15826 int result;
15827 PyObject * obj0 = 0 ;
15828 char *kwnames[] = {
15829 (char *) "self", NULL
15830 };
15831
15832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
15833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15834 if (SWIG_arg_fail(1)) SWIG_fail;
15835 {
15836 PyThreadState* __tstate = wxPyBeginAllowThreads();
15837 result = (int)((wxDC const *)arg1)->GetDepth();
15838
15839 wxPyEndAllowThreads(__tstate);
15840 if (PyErr_Occurred()) SWIG_fail;
15841 }
15842 {
15843 resultobj = SWIG_From_int((int)(result));
15844 }
15845 return resultobj;
15846 fail:
15847 return NULL;
15848 }
15849
15850
15851 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
15852 PyObject *resultobj;
15853 wxDC *arg1 = (wxDC *) 0 ;
15854 wxSize result;
15855 PyObject * obj0 = 0 ;
15856 char *kwnames[] = {
15857 (char *) "self", NULL
15858 };
15859
15860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
15861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15862 if (SWIG_arg_fail(1)) SWIG_fail;
15863 {
15864 PyThreadState* __tstate = wxPyBeginAllowThreads();
15865 result = ((wxDC const *)arg1)->GetPPI();
15866
15867 wxPyEndAllowThreads(__tstate);
15868 if (PyErr_Occurred()) SWIG_fail;
15869 }
15870 {
15871 wxSize * resultptr;
15872 resultptr = new wxSize((wxSize &)(result));
15873 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15874 }
15875 return resultobj;
15876 fail:
15877 return NULL;
15878 }
15879
15880
15881 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
15882 PyObject *resultobj;
15883 wxDC *arg1 = (wxDC *) 0 ;
15884 bool result;
15885 PyObject * obj0 = 0 ;
15886 char *kwnames[] = {
15887 (char *) "self", NULL
15888 };
15889
15890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
15891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15892 if (SWIG_arg_fail(1)) SWIG_fail;
15893 {
15894 PyThreadState* __tstate = wxPyBeginAllowThreads();
15895 result = (bool)((wxDC const *)arg1)->Ok();
15896
15897 wxPyEndAllowThreads(__tstate);
15898 if (PyErr_Occurred()) SWIG_fail;
15899 }
15900 {
15901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15902 }
15903 return resultobj;
15904 fail:
15905 return NULL;
15906 }
15907
15908
15909 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15910 PyObject *resultobj;
15911 wxDC *arg1 = (wxDC *) 0 ;
15912 int result;
15913 PyObject * obj0 = 0 ;
15914 char *kwnames[] = {
15915 (char *) "self", NULL
15916 };
15917
15918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
15919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15920 if (SWIG_arg_fail(1)) SWIG_fail;
15921 {
15922 PyThreadState* __tstate = wxPyBeginAllowThreads();
15923 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
15924
15925 wxPyEndAllowThreads(__tstate);
15926 if (PyErr_Occurred()) SWIG_fail;
15927 }
15928 {
15929 resultobj = SWIG_From_int((int)(result));
15930 }
15931 return resultobj;
15932 fail:
15933 return NULL;
15934 }
15935
15936
15937 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15938 PyObject *resultobj;
15939 wxDC *arg1 = (wxDC *) 0 ;
15940 wxBrush *result;
15941 PyObject * obj0 = 0 ;
15942 char *kwnames[] = {
15943 (char *) "self", NULL
15944 };
15945
15946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
15947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15948 if (SWIG_arg_fail(1)) SWIG_fail;
15949 {
15950 PyThreadState* __tstate = wxPyBeginAllowThreads();
15951 {
15952 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
15953 result = (wxBrush *) &_result_ref;
15954 }
15955
15956 wxPyEndAllowThreads(__tstate);
15957 if (PyErr_Occurred()) SWIG_fail;
15958 }
15959 {
15960 wxBrush* resultptr = new wxBrush(*result);
15961 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15962 }
15963 return resultobj;
15964 fail:
15965 return NULL;
15966 }
15967
15968
15969 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15970 PyObject *resultobj;
15971 wxDC *arg1 = (wxDC *) 0 ;
15972 wxBrush *result;
15973 PyObject * obj0 = 0 ;
15974 char *kwnames[] = {
15975 (char *) "self", NULL
15976 };
15977
15978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
15979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15980 if (SWIG_arg_fail(1)) SWIG_fail;
15981 {
15982 PyThreadState* __tstate = wxPyBeginAllowThreads();
15983 {
15984 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
15985 result = (wxBrush *) &_result_ref;
15986 }
15987
15988 wxPyEndAllowThreads(__tstate);
15989 if (PyErr_Occurred()) SWIG_fail;
15990 }
15991 {
15992 wxBrush* resultptr = new wxBrush(*result);
15993 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15994 }
15995 return resultobj;
15996 fail:
15997 return NULL;
15998 }
15999
16000
16001 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
16002 PyObject *resultobj;
16003 wxDC *arg1 = (wxDC *) 0 ;
16004 wxFont *result;
16005 PyObject * obj0 = 0 ;
16006 char *kwnames[] = {
16007 (char *) "self", NULL
16008 };
16009
16010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
16011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16012 if (SWIG_arg_fail(1)) SWIG_fail;
16013 {
16014 PyThreadState* __tstate = wxPyBeginAllowThreads();
16015 {
16016 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
16017 result = (wxFont *) &_result_ref;
16018 }
16019
16020 wxPyEndAllowThreads(__tstate);
16021 if (PyErr_Occurred()) SWIG_fail;
16022 }
16023 {
16024 wxFont* resultptr = new wxFont(*result);
16025 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
16026 }
16027 return resultobj;
16028 fail:
16029 return NULL;
16030 }
16031
16032
16033 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
16034 PyObject *resultobj;
16035 wxDC *arg1 = (wxDC *) 0 ;
16036 wxPen *result;
16037 PyObject * obj0 = 0 ;
16038 char *kwnames[] = {
16039 (char *) "self", NULL
16040 };
16041
16042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
16043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16044 if (SWIG_arg_fail(1)) SWIG_fail;
16045 {
16046 PyThreadState* __tstate = wxPyBeginAllowThreads();
16047 {
16048 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
16049 result = (wxPen *) &_result_ref;
16050 }
16051
16052 wxPyEndAllowThreads(__tstate);
16053 if (PyErr_Occurred()) SWIG_fail;
16054 }
16055 {
16056 wxPen* resultptr = new wxPen(*result);
16057 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
16058 }
16059 return resultobj;
16060 fail:
16061 return NULL;
16062 }
16063
16064
16065 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16066 PyObject *resultobj;
16067 wxDC *arg1 = (wxDC *) 0 ;
16068 wxColour *result;
16069 PyObject * obj0 = 0 ;
16070 char *kwnames[] = {
16071 (char *) "self", NULL
16072 };
16073
16074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
16075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16076 if (SWIG_arg_fail(1)) SWIG_fail;
16077 {
16078 PyThreadState* __tstate = wxPyBeginAllowThreads();
16079 {
16080 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
16081 result = (wxColour *) &_result_ref;
16082 }
16083
16084 wxPyEndAllowThreads(__tstate);
16085 if (PyErr_Occurred()) SWIG_fail;
16086 }
16087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16088 return resultobj;
16089 fail:
16090 return NULL;
16091 }
16092
16093
16094 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16095 PyObject *resultobj;
16096 wxDC *arg1 = (wxDC *) 0 ;
16097 wxColour *result;
16098 PyObject * obj0 = 0 ;
16099 char *kwnames[] = {
16100 (char *) "self", NULL
16101 };
16102
16103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
16104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16105 if (SWIG_arg_fail(1)) SWIG_fail;
16106 {
16107 PyThreadState* __tstate = wxPyBeginAllowThreads();
16108 {
16109 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
16110 result = (wxColour *) &_result_ref;
16111 }
16112
16113 wxPyEndAllowThreads(__tstate);
16114 if (PyErr_Occurred()) SWIG_fail;
16115 }
16116 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16117 return resultobj;
16118 fail:
16119 return NULL;
16120 }
16121
16122
16123 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16124 PyObject *resultobj;
16125 wxDC *arg1 = (wxDC *) 0 ;
16126 wxColour *arg2 = 0 ;
16127 wxColour temp2 ;
16128 PyObject * obj0 = 0 ;
16129 PyObject * obj1 = 0 ;
16130 char *kwnames[] = {
16131 (char *) "self",(char *) "colour", NULL
16132 };
16133
16134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16136 if (SWIG_arg_fail(1)) SWIG_fail;
16137 {
16138 arg2 = &temp2;
16139 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16140 }
16141 {
16142 PyThreadState* __tstate = wxPyBeginAllowThreads();
16143 (arg1)->SetTextForeground((wxColour const &)*arg2);
16144
16145 wxPyEndAllowThreads(__tstate);
16146 if (PyErr_Occurred()) SWIG_fail;
16147 }
16148 Py_INCREF(Py_None); resultobj = Py_None;
16149 return resultobj;
16150 fail:
16151 return NULL;
16152 }
16153
16154
16155 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16156 PyObject *resultobj;
16157 wxDC *arg1 = (wxDC *) 0 ;
16158 wxColour *arg2 = 0 ;
16159 wxColour temp2 ;
16160 PyObject * obj0 = 0 ;
16161 PyObject * obj1 = 0 ;
16162 char *kwnames[] = {
16163 (char *) "self",(char *) "colour", NULL
16164 };
16165
16166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16168 if (SWIG_arg_fail(1)) SWIG_fail;
16169 {
16170 arg2 = &temp2;
16171 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16172 }
16173 {
16174 PyThreadState* __tstate = wxPyBeginAllowThreads();
16175 (arg1)->SetTextBackground((wxColour const &)*arg2);
16176
16177 wxPyEndAllowThreads(__tstate);
16178 if (PyErr_Occurred()) SWIG_fail;
16179 }
16180 Py_INCREF(Py_None); resultobj = Py_None;
16181 return resultobj;
16182 fail:
16183 return NULL;
16184 }
16185
16186
16187 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16188 PyObject *resultobj;
16189 wxDC *arg1 = (wxDC *) 0 ;
16190 int result;
16191 PyObject * obj0 = 0 ;
16192 char *kwnames[] = {
16193 (char *) "self", NULL
16194 };
16195
16196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16198 if (SWIG_arg_fail(1)) SWIG_fail;
16199 {
16200 PyThreadState* __tstate = wxPyBeginAllowThreads();
16201 result = (int)((wxDC const *)arg1)->GetMapMode();
16202
16203 wxPyEndAllowThreads(__tstate);
16204 if (PyErr_Occurred()) SWIG_fail;
16205 }
16206 {
16207 resultobj = SWIG_From_int((int)(result));
16208 }
16209 return resultobj;
16210 fail:
16211 return NULL;
16212 }
16213
16214
16215 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16216 PyObject *resultobj;
16217 wxDC *arg1 = (wxDC *) 0 ;
16218 int arg2 ;
16219 PyObject * obj0 = 0 ;
16220 PyObject * obj1 = 0 ;
16221 char *kwnames[] = {
16222 (char *) "self",(char *) "mode", NULL
16223 };
16224
16225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16227 if (SWIG_arg_fail(1)) SWIG_fail;
16228 {
16229 arg2 = (int)(SWIG_As_int(obj1));
16230 if (SWIG_arg_fail(2)) SWIG_fail;
16231 }
16232 {
16233 PyThreadState* __tstate = wxPyBeginAllowThreads();
16234 (arg1)->SetMapMode(arg2);
16235
16236 wxPyEndAllowThreads(__tstate);
16237 if (PyErr_Occurred()) SWIG_fail;
16238 }
16239 Py_INCREF(Py_None); resultobj = Py_None;
16240 return resultobj;
16241 fail:
16242 return NULL;
16243 }
16244
16245
16246 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16247 PyObject *resultobj;
16248 wxDC *arg1 = (wxDC *) 0 ;
16249 double *arg2 = (double *) 0 ;
16250 double *arg3 = (double *) 0 ;
16251 double temp2 ;
16252 int res2 = 0 ;
16253 double temp3 ;
16254 int res3 = 0 ;
16255 PyObject * obj0 = 0 ;
16256 char *kwnames[] = {
16257 (char *) "self", NULL
16258 };
16259
16260 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16261 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16264 if (SWIG_arg_fail(1)) SWIG_fail;
16265 {
16266 PyThreadState* __tstate = wxPyBeginAllowThreads();
16267 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16268
16269 wxPyEndAllowThreads(__tstate);
16270 if (PyErr_Occurred()) SWIG_fail;
16271 }
16272 Py_INCREF(Py_None); resultobj = Py_None;
16273 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16274 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16275 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16276 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16277 return resultobj;
16278 fail:
16279 return NULL;
16280 }
16281
16282
16283 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16284 PyObject *resultobj;
16285 wxDC *arg1 = (wxDC *) 0 ;
16286 double arg2 ;
16287 double arg3 ;
16288 PyObject * obj0 = 0 ;
16289 PyObject * obj1 = 0 ;
16290 PyObject * obj2 = 0 ;
16291 char *kwnames[] = {
16292 (char *) "self",(char *) "x",(char *) "y", NULL
16293 };
16294
16295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16297 if (SWIG_arg_fail(1)) SWIG_fail;
16298 {
16299 arg2 = (double)(SWIG_As_double(obj1));
16300 if (SWIG_arg_fail(2)) SWIG_fail;
16301 }
16302 {
16303 arg3 = (double)(SWIG_As_double(obj2));
16304 if (SWIG_arg_fail(3)) SWIG_fail;
16305 }
16306 {
16307 PyThreadState* __tstate = wxPyBeginAllowThreads();
16308 (arg1)->SetUserScale(arg2,arg3);
16309
16310 wxPyEndAllowThreads(__tstate);
16311 if (PyErr_Occurred()) SWIG_fail;
16312 }
16313 Py_INCREF(Py_None); resultobj = Py_None;
16314 return resultobj;
16315 fail:
16316 return NULL;
16317 }
16318
16319
16320 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16321 PyObject *resultobj;
16322 wxDC *arg1 = (wxDC *) 0 ;
16323 double *arg2 = (double *) 0 ;
16324 double *arg3 = (double *) 0 ;
16325 double temp2 ;
16326 int res2 = 0 ;
16327 double temp3 ;
16328 int res3 = 0 ;
16329 PyObject * obj0 = 0 ;
16330 char *kwnames[] = {
16331 (char *) "self", NULL
16332 };
16333
16334 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16335 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16338 if (SWIG_arg_fail(1)) SWIG_fail;
16339 {
16340 PyThreadState* __tstate = wxPyBeginAllowThreads();
16341 (arg1)->GetLogicalScale(arg2,arg3);
16342
16343 wxPyEndAllowThreads(__tstate);
16344 if (PyErr_Occurred()) SWIG_fail;
16345 }
16346 Py_INCREF(Py_None); resultobj = Py_None;
16347 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16348 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16349 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16350 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16351 return resultobj;
16352 fail:
16353 return NULL;
16354 }
16355
16356
16357 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16358 PyObject *resultobj;
16359 wxDC *arg1 = (wxDC *) 0 ;
16360 double arg2 ;
16361 double arg3 ;
16362 PyObject * obj0 = 0 ;
16363 PyObject * obj1 = 0 ;
16364 PyObject * obj2 = 0 ;
16365 char *kwnames[] = {
16366 (char *) "self",(char *) "x",(char *) "y", NULL
16367 };
16368
16369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16371 if (SWIG_arg_fail(1)) SWIG_fail;
16372 {
16373 arg2 = (double)(SWIG_As_double(obj1));
16374 if (SWIG_arg_fail(2)) SWIG_fail;
16375 }
16376 {
16377 arg3 = (double)(SWIG_As_double(obj2));
16378 if (SWIG_arg_fail(3)) SWIG_fail;
16379 }
16380 {
16381 PyThreadState* __tstate = wxPyBeginAllowThreads();
16382 (arg1)->SetLogicalScale(arg2,arg3);
16383
16384 wxPyEndAllowThreads(__tstate);
16385 if (PyErr_Occurred()) SWIG_fail;
16386 }
16387 Py_INCREF(Py_None); resultobj = Py_None;
16388 return resultobj;
16389 fail:
16390 return NULL;
16391 }
16392
16393
16394 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16395 PyObject *resultobj;
16396 wxDC *arg1 = (wxDC *) 0 ;
16397 wxPoint result;
16398 PyObject * obj0 = 0 ;
16399 char *kwnames[] = {
16400 (char *) "self", NULL
16401 };
16402
16403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16405 if (SWIG_arg_fail(1)) SWIG_fail;
16406 {
16407 PyThreadState* __tstate = wxPyBeginAllowThreads();
16408 result = ((wxDC const *)arg1)->GetLogicalOrigin();
16409
16410 wxPyEndAllowThreads(__tstate);
16411 if (PyErr_Occurred()) SWIG_fail;
16412 }
16413 {
16414 wxPoint * resultptr;
16415 resultptr = new wxPoint((wxPoint &)(result));
16416 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16417 }
16418 return resultobj;
16419 fail:
16420 return NULL;
16421 }
16422
16423
16424 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16425 PyObject *resultobj;
16426 wxDC *arg1 = (wxDC *) 0 ;
16427 int *arg2 = (int *) 0 ;
16428 int *arg3 = (int *) 0 ;
16429 int temp2 ;
16430 int res2 = 0 ;
16431 int temp3 ;
16432 int res3 = 0 ;
16433 PyObject * obj0 = 0 ;
16434 char *kwnames[] = {
16435 (char *) "self", NULL
16436 };
16437
16438 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16439 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
16441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16442 if (SWIG_arg_fail(1)) SWIG_fail;
16443 {
16444 PyThreadState* __tstate = wxPyBeginAllowThreads();
16445 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
16446
16447 wxPyEndAllowThreads(__tstate);
16448 if (PyErr_Occurred()) SWIG_fail;
16449 }
16450 Py_INCREF(Py_None); resultobj = Py_None;
16451 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16452 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16453 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16454 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16455 return resultobj;
16456 fail:
16457 return NULL;
16458 }
16459
16460
16461 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16462 PyObject *resultobj;
16463 wxDC *arg1 = (wxDC *) 0 ;
16464 int arg2 ;
16465 int arg3 ;
16466 PyObject * obj0 = 0 ;
16467 PyObject * obj1 = 0 ;
16468 PyObject * obj2 = 0 ;
16469 char *kwnames[] = {
16470 (char *) "self",(char *) "x",(char *) "y", NULL
16471 };
16472
16473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16475 if (SWIG_arg_fail(1)) SWIG_fail;
16476 {
16477 arg2 = (int)(SWIG_As_int(obj1));
16478 if (SWIG_arg_fail(2)) SWIG_fail;
16479 }
16480 {
16481 arg3 = (int)(SWIG_As_int(obj2));
16482 if (SWIG_arg_fail(3)) SWIG_fail;
16483 }
16484 {
16485 PyThreadState* __tstate = wxPyBeginAllowThreads();
16486 (arg1)->SetLogicalOrigin(arg2,arg3);
16487
16488 wxPyEndAllowThreads(__tstate);
16489 if (PyErr_Occurred()) SWIG_fail;
16490 }
16491 Py_INCREF(Py_None); resultobj = Py_None;
16492 return resultobj;
16493 fail:
16494 return NULL;
16495 }
16496
16497
16498 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16499 PyObject *resultobj;
16500 wxDC *arg1 = (wxDC *) 0 ;
16501 wxPoint *arg2 = 0 ;
16502 wxPoint temp2 ;
16503 PyObject * obj0 = 0 ;
16504 PyObject * obj1 = 0 ;
16505 char *kwnames[] = {
16506 (char *) "self",(char *) "point", NULL
16507 };
16508
16509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16511 if (SWIG_arg_fail(1)) SWIG_fail;
16512 {
16513 arg2 = &temp2;
16514 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16515 }
16516 {
16517 PyThreadState* __tstate = wxPyBeginAllowThreads();
16518 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
16519
16520 wxPyEndAllowThreads(__tstate);
16521 if (PyErr_Occurred()) SWIG_fail;
16522 }
16523 Py_INCREF(Py_None); resultobj = Py_None;
16524 return resultobj;
16525 fail:
16526 return NULL;
16527 }
16528
16529
16530 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16531 PyObject *resultobj;
16532 wxDC *arg1 = (wxDC *) 0 ;
16533 wxPoint result;
16534 PyObject * obj0 = 0 ;
16535 char *kwnames[] = {
16536 (char *) "self", NULL
16537 };
16538
16539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
16540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16541 if (SWIG_arg_fail(1)) SWIG_fail;
16542 {
16543 PyThreadState* __tstate = wxPyBeginAllowThreads();
16544 result = ((wxDC const *)arg1)->GetDeviceOrigin();
16545
16546 wxPyEndAllowThreads(__tstate);
16547 if (PyErr_Occurred()) SWIG_fail;
16548 }
16549 {
16550 wxPoint * resultptr;
16551 resultptr = new wxPoint((wxPoint &)(result));
16552 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16553 }
16554 return resultobj;
16555 fail:
16556 return NULL;
16557 }
16558
16559
16560 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16561 PyObject *resultobj;
16562 wxDC *arg1 = (wxDC *) 0 ;
16563 int *arg2 = (int *) 0 ;
16564 int *arg3 = (int *) 0 ;
16565 int temp2 ;
16566 int res2 = 0 ;
16567 int temp3 ;
16568 int res3 = 0 ;
16569 PyObject * obj0 = 0 ;
16570 char *kwnames[] = {
16571 (char *) "self", NULL
16572 };
16573
16574 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16575 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
16577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16578 if (SWIG_arg_fail(1)) SWIG_fail;
16579 {
16580 PyThreadState* __tstate = wxPyBeginAllowThreads();
16581 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
16582
16583 wxPyEndAllowThreads(__tstate);
16584 if (PyErr_Occurred()) SWIG_fail;
16585 }
16586 Py_INCREF(Py_None); resultobj = Py_None;
16587 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16588 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16589 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16590 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16591 return resultobj;
16592 fail:
16593 return NULL;
16594 }
16595
16596
16597 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16598 PyObject *resultobj;
16599 wxDC *arg1 = (wxDC *) 0 ;
16600 int arg2 ;
16601 int arg3 ;
16602 PyObject * obj0 = 0 ;
16603 PyObject * obj1 = 0 ;
16604 PyObject * obj2 = 0 ;
16605 char *kwnames[] = {
16606 (char *) "self",(char *) "x",(char *) "y", NULL
16607 };
16608
16609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16611 if (SWIG_arg_fail(1)) SWIG_fail;
16612 {
16613 arg2 = (int)(SWIG_As_int(obj1));
16614 if (SWIG_arg_fail(2)) SWIG_fail;
16615 }
16616 {
16617 arg3 = (int)(SWIG_As_int(obj2));
16618 if (SWIG_arg_fail(3)) SWIG_fail;
16619 }
16620 {
16621 PyThreadState* __tstate = wxPyBeginAllowThreads();
16622 (arg1)->SetDeviceOrigin(arg2,arg3);
16623
16624 wxPyEndAllowThreads(__tstate);
16625 if (PyErr_Occurred()) SWIG_fail;
16626 }
16627 Py_INCREF(Py_None); resultobj = Py_None;
16628 return resultobj;
16629 fail:
16630 return NULL;
16631 }
16632
16633
16634 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16635 PyObject *resultobj;
16636 wxDC *arg1 = (wxDC *) 0 ;
16637 wxPoint *arg2 = 0 ;
16638 wxPoint temp2 ;
16639 PyObject * obj0 = 0 ;
16640 PyObject * obj1 = 0 ;
16641 char *kwnames[] = {
16642 (char *) "self",(char *) "point", NULL
16643 };
16644
16645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16647 if (SWIG_arg_fail(1)) SWIG_fail;
16648 {
16649 arg2 = &temp2;
16650 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16651 }
16652 {
16653 PyThreadState* __tstate = wxPyBeginAllowThreads();
16654 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
16655
16656 wxPyEndAllowThreads(__tstate);
16657 if (PyErr_Occurred()) SWIG_fail;
16658 }
16659 Py_INCREF(Py_None); resultobj = Py_None;
16660 return resultobj;
16661 fail:
16662 return NULL;
16663 }
16664
16665
16666 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16667 PyObject *resultobj;
16668 wxDC *arg1 = (wxDC *) 0 ;
16669 bool arg2 ;
16670 bool arg3 ;
16671 PyObject * obj0 = 0 ;
16672 PyObject * obj1 = 0 ;
16673 PyObject * obj2 = 0 ;
16674 char *kwnames[] = {
16675 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
16676 };
16677
16678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
16679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16680 if (SWIG_arg_fail(1)) SWIG_fail;
16681 {
16682 arg2 = (bool)(SWIG_As_bool(obj1));
16683 if (SWIG_arg_fail(2)) SWIG_fail;
16684 }
16685 {
16686 arg3 = (bool)(SWIG_As_bool(obj2));
16687 if (SWIG_arg_fail(3)) SWIG_fail;
16688 }
16689 {
16690 PyThreadState* __tstate = wxPyBeginAllowThreads();
16691 (arg1)->SetAxisOrientation(arg2,arg3);
16692
16693 wxPyEndAllowThreads(__tstate);
16694 if (PyErr_Occurred()) SWIG_fail;
16695 }
16696 Py_INCREF(Py_None); resultobj = Py_None;
16697 return resultobj;
16698 fail:
16699 return NULL;
16700 }
16701
16702
16703 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16704 PyObject *resultobj;
16705 wxDC *arg1 = (wxDC *) 0 ;
16706 int result;
16707 PyObject * obj0 = 0 ;
16708 char *kwnames[] = {
16709 (char *) "self", NULL
16710 };
16711
16712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
16713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16714 if (SWIG_arg_fail(1)) SWIG_fail;
16715 {
16716 PyThreadState* __tstate = wxPyBeginAllowThreads();
16717 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
16718
16719 wxPyEndAllowThreads(__tstate);
16720 if (PyErr_Occurred()) SWIG_fail;
16721 }
16722 {
16723 resultobj = SWIG_From_int((int)(result));
16724 }
16725 return resultobj;
16726 fail:
16727 return NULL;
16728 }
16729
16730
16731 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16732 PyObject *resultobj;
16733 wxDC *arg1 = (wxDC *) 0 ;
16734 int arg2 ;
16735 PyObject * obj0 = 0 ;
16736 PyObject * obj1 = 0 ;
16737 char *kwnames[] = {
16738 (char *) "self",(char *) "function", NULL
16739 };
16740
16741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
16742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16743 if (SWIG_arg_fail(1)) SWIG_fail;
16744 {
16745 arg2 = (int)(SWIG_As_int(obj1));
16746 if (SWIG_arg_fail(2)) SWIG_fail;
16747 }
16748 {
16749 PyThreadState* __tstate = wxPyBeginAllowThreads();
16750 (arg1)->SetLogicalFunction(arg2);
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_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16763 PyObject *resultobj;
16764 wxDC *arg1 = (wxDC *) 0 ;
16765 PyObject * obj0 = 0 ;
16766 char *kwnames[] = {
16767 (char *) "self", NULL
16768 };
16769
16770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
16771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16772 if (SWIG_arg_fail(1)) SWIG_fail;
16773 {
16774 PyThreadState* __tstate = wxPyBeginAllowThreads();
16775 (arg1)->ComputeScaleAndOrigin();
16776
16777 wxPyEndAllowThreads(__tstate);
16778 if (PyErr_Occurred()) SWIG_fail;
16779 }
16780 Py_INCREF(Py_None); resultobj = Py_None;
16781 return resultobj;
16782 fail:
16783 return NULL;
16784 }
16785
16786
16787 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16788 PyObject *resultobj;
16789 wxDC *arg1 = (wxDC *) 0 ;
16790 int arg2 ;
16791 int arg3 ;
16792 PyObject * obj0 = 0 ;
16793 PyObject * obj1 = 0 ;
16794 PyObject * obj2 = 0 ;
16795 char *kwnames[] = {
16796 (char *) "self",(char *) "x",(char *) "y", NULL
16797 };
16798
16799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
16800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16801 if (SWIG_arg_fail(1)) SWIG_fail;
16802 {
16803 arg2 = (int)(SWIG_As_int(obj1));
16804 if (SWIG_arg_fail(2)) SWIG_fail;
16805 }
16806 {
16807 arg3 = (int)(SWIG_As_int(obj2));
16808 if (SWIG_arg_fail(3)) SWIG_fail;
16809 }
16810 {
16811 PyThreadState* __tstate = wxPyBeginAllowThreads();
16812 (arg1)->CalcBoundingBox(arg2,arg3);
16813
16814 wxPyEndAllowThreads(__tstate);
16815 if (PyErr_Occurred()) SWIG_fail;
16816 }
16817 Py_INCREF(Py_None); resultobj = Py_None;
16818 return resultobj;
16819 fail:
16820 return NULL;
16821 }
16822
16823
16824 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16825 PyObject *resultobj;
16826 wxDC *arg1 = (wxDC *) 0 ;
16827 wxPoint *arg2 = 0 ;
16828 wxPoint temp2 ;
16829 PyObject * obj0 = 0 ;
16830 PyObject * obj1 = 0 ;
16831 char *kwnames[] = {
16832 (char *) "self",(char *) "point", NULL
16833 };
16834
16835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
16836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16837 if (SWIG_arg_fail(1)) SWIG_fail;
16838 {
16839 arg2 = &temp2;
16840 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16841 }
16842 {
16843 PyThreadState* __tstate = wxPyBeginAllowThreads();
16844 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
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_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16857 PyObject *resultobj;
16858 wxDC *arg1 = (wxDC *) 0 ;
16859 PyObject * obj0 = 0 ;
16860 char *kwnames[] = {
16861 (char *) "self", NULL
16862 };
16863
16864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
16865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16866 if (SWIG_arg_fail(1)) SWIG_fail;
16867 {
16868 PyThreadState* __tstate = wxPyBeginAllowThreads();
16869 (arg1)->ResetBoundingBox();
16870
16871 wxPyEndAllowThreads(__tstate);
16872 if (PyErr_Occurred()) SWIG_fail;
16873 }
16874 Py_INCREF(Py_None); resultobj = Py_None;
16875 return resultobj;
16876 fail:
16877 return NULL;
16878 }
16879
16880
16881 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
16882 PyObject *resultobj;
16883 wxDC *arg1 = (wxDC *) 0 ;
16884 int result;
16885 PyObject * obj0 = 0 ;
16886 char *kwnames[] = {
16887 (char *) "self", NULL
16888 };
16889
16890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
16891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16892 if (SWIG_arg_fail(1)) SWIG_fail;
16893 {
16894 PyThreadState* __tstate = wxPyBeginAllowThreads();
16895 result = (int)((wxDC const *)arg1)->MinX();
16896
16897 wxPyEndAllowThreads(__tstate);
16898 if (PyErr_Occurred()) SWIG_fail;
16899 }
16900 {
16901 resultobj = SWIG_From_int((int)(result));
16902 }
16903 return resultobj;
16904 fail:
16905 return NULL;
16906 }
16907
16908
16909 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
16910 PyObject *resultobj;
16911 wxDC *arg1 = (wxDC *) 0 ;
16912 int result;
16913 PyObject * obj0 = 0 ;
16914 char *kwnames[] = {
16915 (char *) "self", NULL
16916 };
16917
16918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
16919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16920 if (SWIG_arg_fail(1)) SWIG_fail;
16921 {
16922 PyThreadState* __tstate = wxPyBeginAllowThreads();
16923 result = (int)((wxDC const *)arg1)->MaxX();
16924
16925 wxPyEndAllowThreads(__tstate);
16926 if (PyErr_Occurred()) SWIG_fail;
16927 }
16928 {
16929 resultobj = SWIG_From_int((int)(result));
16930 }
16931 return resultobj;
16932 fail:
16933 return NULL;
16934 }
16935
16936
16937 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
16938 PyObject *resultobj;
16939 wxDC *arg1 = (wxDC *) 0 ;
16940 int result;
16941 PyObject * obj0 = 0 ;
16942 char *kwnames[] = {
16943 (char *) "self", NULL
16944 };
16945
16946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
16947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16948 if (SWIG_arg_fail(1)) SWIG_fail;
16949 {
16950 PyThreadState* __tstate = wxPyBeginAllowThreads();
16951 result = (int)((wxDC const *)arg1)->MinY();
16952
16953 wxPyEndAllowThreads(__tstate);
16954 if (PyErr_Occurred()) SWIG_fail;
16955 }
16956 {
16957 resultobj = SWIG_From_int((int)(result));
16958 }
16959 return resultobj;
16960 fail:
16961 return NULL;
16962 }
16963
16964
16965 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
16966 PyObject *resultobj;
16967 wxDC *arg1 = (wxDC *) 0 ;
16968 int result;
16969 PyObject * obj0 = 0 ;
16970 char *kwnames[] = {
16971 (char *) "self", NULL
16972 };
16973
16974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
16975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16976 if (SWIG_arg_fail(1)) SWIG_fail;
16977 {
16978 PyThreadState* __tstate = wxPyBeginAllowThreads();
16979 result = (int)((wxDC const *)arg1)->MaxY();
16980
16981 wxPyEndAllowThreads(__tstate);
16982 if (PyErr_Occurred()) SWIG_fail;
16983 }
16984 {
16985 resultobj = SWIG_From_int((int)(result));
16986 }
16987 return resultobj;
16988 fail:
16989 return NULL;
16990 }
16991
16992
16993 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16994 PyObject *resultobj;
16995 wxDC *arg1 = (wxDC *) 0 ;
16996 int *arg2 = (int *) 0 ;
16997 int *arg3 = (int *) 0 ;
16998 int *arg4 = (int *) 0 ;
16999 int *arg5 = (int *) 0 ;
17000 int temp2 ;
17001 int res2 = 0 ;
17002 int temp3 ;
17003 int res3 = 0 ;
17004 int temp4 ;
17005 int res4 = 0 ;
17006 int temp5 ;
17007 int res5 = 0 ;
17008 PyObject * obj0 = 0 ;
17009 char *kwnames[] = {
17010 (char *) "self", NULL
17011 };
17012
17013 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17014 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17015 arg4 = &temp4; res4 = SWIG_NEWOBJ;
17016 arg5 = &temp5; res5 = SWIG_NEWOBJ;
17017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
17018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17019 if (SWIG_arg_fail(1)) SWIG_fail;
17020 {
17021 PyThreadState* __tstate = wxPyBeginAllowThreads();
17022 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
17023
17024 wxPyEndAllowThreads(__tstate);
17025 if (PyErr_Occurred()) SWIG_fail;
17026 }
17027 Py_INCREF(Py_None); resultobj = Py_None;
17028 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17029 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17030 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17031 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17032 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
17033 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
17034 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
17035 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
17036 return resultobj;
17037 fail:
17038 return NULL;
17039 }
17040
17041
17042 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
17043 PyObject *resultobj;
17044 wxDC *arg1 = (wxDC *) 0 ;
17045 PyObject *arg2 = (PyObject *) 0 ;
17046 PyObject *arg3 = (PyObject *) 0 ;
17047 PyObject *arg4 = (PyObject *) 0 ;
17048 PyObject *result;
17049 PyObject * obj0 = 0 ;
17050 PyObject * obj1 = 0 ;
17051 PyObject * obj2 = 0 ;
17052 PyObject * obj3 = 0 ;
17053 char *kwnames[] = {
17054 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17055 };
17056
17057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17059 if (SWIG_arg_fail(1)) SWIG_fail;
17060 arg2 = obj1;
17061 arg3 = obj2;
17062 arg4 = obj3;
17063 {
17064 PyThreadState* __tstate = wxPyBeginAllowThreads();
17065 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
17066
17067 wxPyEndAllowThreads(__tstate);
17068 if (PyErr_Occurred()) SWIG_fail;
17069 }
17070 resultobj = result;
17071 return resultobj;
17072 fail:
17073 return NULL;
17074 }
17075
17076
17077 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
17078 PyObject *resultobj;
17079 wxDC *arg1 = (wxDC *) 0 ;
17080 PyObject *arg2 = (PyObject *) 0 ;
17081 PyObject *arg3 = (PyObject *) 0 ;
17082 PyObject *arg4 = (PyObject *) 0 ;
17083 PyObject *result;
17084 PyObject * obj0 = 0 ;
17085 PyObject * obj1 = 0 ;
17086 PyObject * obj2 = 0 ;
17087 PyObject * obj3 = 0 ;
17088 char *kwnames[] = {
17089 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17090 };
17091
17092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17094 if (SWIG_arg_fail(1)) SWIG_fail;
17095 arg2 = obj1;
17096 arg3 = obj2;
17097 arg4 = obj3;
17098 {
17099 PyThreadState* __tstate = wxPyBeginAllowThreads();
17100 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
17101
17102 wxPyEndAllowThreads(__tstate);
17103 if (PyErr_Occurred()) SWIG_fail;
17104 }
17105 resultobj = result;
17106 return resultobj;
17107 fail:
17108 return NULL;
17109 }
17110
17111
17112 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
17113 PyObject *resultobj;
17114 wxDC *arg1 = (wxDC *) 0 ;
17115 PyObject *arg2 = (PyObject *) 0 ;
17116 PyObject *arg3 = (PyObject *) 0 ;
17117 PyObject *arg4 = (PyObject *) 0 ;
17118 PyObject *result;
17119 PyObject * obj0 = 0 ;
17120 PyObject * obj1 = 0 ;
17121 PyObject * obj2 = 0 ;
17122 PyObject * obj3 = 0 ;
17123 char *kwnames[] = {
17124 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17125 };
17126
17127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17129 if (SWIG_arg_fail(1)) SWIG_fail;
17130 arg2 = obj1;
17131 arg3 = obj2;
17132 arg4 = obj3;
17133 {
17134 PyThreadState* __tstate = wxPyBeginAllowThreads();
17135 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17136
17137 wxPyEndAllowThreads(__tstate);
17138 if (PyErr_Occurred()) SWIG_fail;
17139 }
17140 resultobj = result;
17141 return resultobj;
17142 fail:
17143 return NULL;
17144 }
17145
17146
17147 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17148 PyObject *resultobj;
17149 wxDC *arg1 = (wxDC *) 0 ;
17150 PyObject *arg2 = (PyObject *) 0 ;
17151 PyObject *arg3 = (PyObject *) 0 ;
17152 PyObject *arg4 = (PyObject *) 0 ;
17153 PyObject *result;
17154 PyObject * obj0 = 0 ;
17155 PyObject * obj1 = 0 ;
17156 PyObject * obj2 = 0 ;
17157 PyObject * obj3 = 0 ;
17158 char *kwnames[] = {
17159 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17160 };
17161
17162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17164 if (SWIG_arg_fail(1)) SWIG_fail;
17165 arg2 = obj1;
17166 arg3 = obj2;
17167 arg4 = obj3;
17168 {
17169 PyThreadState* __tstate = wxPyBeginAllowThreads();
17170 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17171
17172 wxPyEndAllowThreads(__tstate);
17173 if (PyErr_Occurred()) SWIG_fail;
17174 }
17175 resultobj = result;
17176 return resultobj;
17177 fail:
17178 return NULL;
17179 }
17180
17181
17182 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17183 PyObject *resultobj;
17184 wxDC *arg1 = (wxDC *) 0 ;
17185 PyObject *arg2 = (PyObject *) 0 ;
17186 PyObject *arg3 = (PyObject *) 0 ;
17187 PyObject *arg4 = (PyObject *) 0 ;
17188 PyObject *result;
17189 PyObject * obj0 = 0 ;
17190 PyObject * obj1 = 0 ;
17191 PyObject * obj2 = 0 ;
17192 PyObject * obj3 = 0 ;
17193 char *kwnames[] = {
17194 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17195 };
17196
17197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17199 if (SWIG_arg_fail(1)) SWIG_fail;
17200 arg2 = obj1;
17201 arg3 = obj2;
17202 arg4 = obj3;
17203 {
17204 PyThreadState* __tstate = wxPyBeginAllowThreads();
17205 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17206
17207 wxPyEndAllowThreads(__tstate);
17208 if (PyErr_Occurred()) SWIG_fail;
17209 }
17210 resultobj = result;
17211 return resultobj;
17212 fail:
17213 return NULL;
17214 }
17215
17216
17217 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17218 PyObject *resultobj;
17219 wxDC *arg1 = (wxDC *) 0 ;
17220 PyObject *arg2 = (PyObject *) 0 ;
17221 PyObject *arg3 = (PyObject *) 0 ;
17222 PyObject *arg4 = (PyObject *) 0 ;
17223 PyObject *arg5 = (PyObject *) 0 ;
17224 PyObject *result;
17225 PyObject * obj0 = 0 ;
17226 PyObject * obj1 = 0 ;
17227 PyObject * obj2 = 0 ;
17228 PyObject * obj3 = 0 ;
17229 PyObject * obj4 = 0 ;
17230 char *kwnames[] = {
17231 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17232 };
17233
17234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17236 if (SWIG_arg_fail(1)) SWIG_fail;
17237 arg2 = obj1;
17238 arg3 = obj2;
17239 arg4 = obj3;
17240 arg5 = obj4;
17241 {
17242 PyThreadState* __tstate = wxPyBeginAllowThreads();
17243 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17244
17245 wxPyEndAllowThreads(__tstate);
17246 if (PyErr_Occurred()) SWIG_fail;
17247 }
17248 resultobj = result;
17249 return resultobj;
17250 fail:
17251 return NULL;
17252 }
17253
17254
17255 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17256 PyObject *obj;
17257 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17258 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17259 Py_INCREF(obj);
17260 return Py_BuildValue((char *)"");
17261 }
17262 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17263 PyObject *resultobj;
17264 wxMemoryDC *result;
17265 char *kwnames[] = {
17266 NULL
17267 };
17268
17269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17270 {
17271 if (!wxPyCheckForApp()) SWIG_fail;
17272 PyThreadState* __tstate = wxPyBeginAllowThreads();
17273 result = (wxMemoryDC *)new wxMemoryDC();
17274
17275 wxPyEndAllowThreads(__tstate);
17276 if (PyErr_Occurred()) SWIG_fail;
17277 }
17278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17279 return resultobj;
17280 fail:
17281 return NULL;
17282 }
17283
17284
17285 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17286 PyObject *resultobj;
17287 wxDC *arg1 = (wxDC *) 0 ;
17288 wxMemoryDC *result;
17289 PyObject * obj0 = 0 ;
17290 char *kwnames[] = {
17291 (char *) "oldDC", NULL
17292 };
17293
17294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17296 if (SWIG_arg_fail(1)) SWIG_fail;
17297 {
17298 if (!wxPyCheckForApp()) SWIG_fail;
17299 PyThreadState* __tstate = wxPyBeginAllowThreads();
17300 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17301
17302 wxPyEndAllowThreads(__tstate);
17303 if (PyErr_Occurred()) SWIG_fail;
17304 }
17305 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17306 return resultobj;
17307 fail:
17308 return NULL;
17309 }
17310
17311
17312 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17313 PyObject *resultobj;
17314 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17315 wxBitmap *arg2 = 0 ;
17316 PyObject * obj0 = 0 ;
17317 PyObject * obj1 = 0 ;
17318 char *kwnames[] = {
17319 (char *) "self",(char *) "bitmap", NULL
17320 };
17321
17322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17324 if (SWIG_arg_fail(1)) SWIG_fail;
17325 {
17326 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17327 if (SWIG_arg_fail(2)) SWIG_fail;
17328 if (arg2 == NULL) {
17329 SWIG_null_ref("wxBitmap");
17330 }
17331 if (SWIG_arg_fail(2)) SWIG_fail;
17332 }
17333 {
17334 PyThreadState* __tstate = wxPyBeginAllowThreads();
17335 (arg1)->SelectObject((wxBitmap const &)*arg2);
17336
17337 wxPyEndAllowThreads(__tstate);
17338 if (PyErr_Occurred()) SWIG_fail;
17339 }
17340 Py_INCREF(Py_None); resultobj = Py_None;
17341 return resultobj;
17342 fail:
17343 return NULL;
17344 }
17345
17346
17347 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17348 PyObject *obj;
17349 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17350 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17351 Py_INCREF(obj);
17352 return Py_BuildValue((char *)"");
17353 }
17354 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17355 PyObject *resultobj;
17356 wxDC *arg1 = (wxDC *) 0 ;
17357 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17358 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17359 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17360 wxBufferedDC *result;
17361 PyObject * obj0 = 0 ;
17362 PyObject * obj1 = 0 ;
17363 PyObject * obj2 = 0 ;
17364
17365 if(!PyArg_ParseTuple(args,(char *)"O|OO:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17367 if (SWIG_arg_fail(1)) SWIG_fail;
17368 if (obj1) {
17369 {
17370 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17371 if (SWIG_arg_fail(2)) SWIG_fail;
17372 if (arg2 == NULL) {
17373 SWIG_null_ref("wxBitmap");
17374 }
17375 if (SWIG_arg_fail(2)) SWIG_fail;
17376 }
17377 }
17378 if (obj2) {
17379 {
17380 arg3 = (int)(SWIG_As_int(obj2));
17381 if (SWIG_arg_fail(3)) SWIG_fail;
17382 }
17383 }
17384 {
17385 if (!wxPyCheckForApp()) SWIG_fail;
17386 PyThreadState* __tstate = wxPyBeginAllowThreads();
17387 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
17388
17389 wxPyEndAllowThreads(__tstate);
17390 if (PyErr_Occurred()) SWIG_fail;
17391 }
17392 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17393 return resultobj;
17394 fail:
17395 return NULL;
17396 }
17397
17398
17399 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17400 PyObject *resultobj;
17401 wxDC *arg1 = (wxDC *) 0 ;
17402 wxSize *arg2 = 0 ;
17403 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17404 wxBufferedDC *result;
17405 wxSize temp2 ;
17406 PyObject * obj0 = 0 ;
17407 PyObject * obj1 = 0 ;
17408 PyObject * obj2 = 0 ;
17409
17410 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17412 if (SWIG_arg_fail(1)) SWIG_fail;
17413 {
17414 arg2 = &temp2;
17415 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17416 }
17417 if (obj2) {
17418 {
17419 arg3 = (int)(SWIG_As_int(obj2));
17420 if (SWIG_arg_fail(3)) SWIG_fail;
17421 }
17422 }
17423 {
17424 if (!wxPyCheckForApp()) SWIG_fail;
17425 PyThreadState* __tstate = wxPyBeginAllowThreads();
17426 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
17427
17428 wxPyEndAllowThreads(__tstate);
17429 if (PyErr_Occurred()) SWIG_fail;
17430 }
17431 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17432 return resultobj;
17433 fail:
17434 return NULL;
17435 }
17436
17437
17438 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
17439 int argc;
17440 PyObject *argv[4];
17441 int ii;
17442
17443 argc = PyObject_Length(args);
17444 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
17445 argv[ii] = PyTuple_GetItem(args,ii);
17446 }
17447 if ((argc >= 1) && (argc <= 3)) {
17448 int _v;
17449 {
17450 void *ptr;
17451 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17452 _v = 0;
17453 PyErr_Clear();
17454 } else {
17455 _v = 1;
17456 }
17457 }
17458 if (_v) {
17459 if (argc <= 1) {
17460 return _wrap_new_BufferedDC__SWIG_0(self,args);
17461 }
17462 {
17463 void *ptr = 0;
17464 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
17465 _v = 0;
17466 PyErr_Clear();
17467 } else {
17468 _v = (ptr != 0);
17469 }
17470 }
17471 if (_v) {
17472 if (argc <= 2) {
17473 return _wrap_new_BufferedDC__SWIG_0(self,args);
17474 }
17475 _v = SWIG_Check_int(argv[2]);
17476 if (_v) {
17477 return _wrap_new_BufferedDC__SWIG_0(self,args);
17478 }
17479 }
17480 }
17481 }
17482 if ((argc >= 2) && (argc <= 3)) {
17483 int _v;
17484 {
17485 void *ptr;
17486 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17487 _v = 0;
17488 PyErr_Clear();
17489 } else {
17490 _v = 1;
17491 }
17492 }
17493 if (_v) {
17494 {
17495 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
17496 }
17497 if (_v) {
17498 if (argc <= 2) {
17499 return _wrap_new_BufferedDC__SWIG_1(self,args);
17500 }
17501 _v = SWIG_Check_int(argv[2]);
17502 if (_v) {
17503 return _wrap_new_BufferedDC__SWIG_1(self,args);
17504 }
17505 }
17506 }
17507 }
17508
17509 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
17510 return NULL;
17511 }
17512
17513
17514 static PyObject *_wrap_delete_BufferedDC(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:delete_BufferedDC",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 delete arg1;
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 *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
17540 PyObject *resultobj;
17541 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17542 PyObject * obj0 = 0 ;
17543 char *kwnames[] = {
17544 (char *) "self", NULL
17545 };
17546
17547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
17548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17549 if (SWIG_arg_fail(1)) SWIG_fail;
17550 {
17551 PyThreadState* __tstate = wxPyBeginAllowThreads();
17552 (arg1)->UnMask();
17553
17554 wxPyEndAllowThreads(__tstate);
17555 if (PyErr_Occurred()) SWIG_fail;
17556 }
17557 Py_INCREF(Py_None); resultobj = Py_None;
17558 return resultobj;
17559 fail:
17560 return NULL;
17561 }
17562
17563
17564 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
17565 PyObject *obj;
17566 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17567 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
17568 Py_INCREF(obj);
17569 return Py_BuildValue((char *)"");
17570 }
17571 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17572 PyObject *resultobj;
17573 wxWindow *arg1 = (wxWindow *) 0 ;
17574 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17575 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17576 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17577 wxBufferedPaintDC *result;
17578 PyObject * obj0 = 0 ;
17579 PyObject * obj1 = 0 ;
17580 PyObject * obj2 = 0 ;
17581 char *kwnames[] = {
17582 (char *) "window",(char *) "buffer",(char *) "style", NULL
17583 };
17584
17585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
17586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17587 if (SWIG_arg_fail(1)) SWIG_fail;
17588 if (obj1) {
17589 {
17590 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17591 if (SWIG_arg_fail(2)) SWIG_fail;
17592 if (arg2 == NULL) {
17593 SWIG_null_ref("wxBitmap");
17594 }
17595 if (SWIG_arg_fail(2)) SWIG_fail;
17596 }
17597 }
17598 if (obj2) {
17599 {
17600 arg3 = (int)(SWIG_As_int(obj2));
17601 if (SWIG_arg_fail(3)) SWIG_fail;
17602 }
17603 }
17604 {
17605 if (!wxPyCheckForApp()) SWIG_fail;
17606 PyThreadState* __tstate = wxPyBeginAllowThreads();
17607 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
17608
17609 wxPyEndAllowThreads(__tstate);
17610 if (PyErr_Occurred()) SWIG_fail;
17611 }
17612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
17613 return resultobj;
17614 fail:
17615 return NULL;
17616 }
17617
17618
17619 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
17620 PyObject *obj;
17621 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17622 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
17623 Py_INCREF(obj);
17624 return Py_BuildValue((char *)"");
17625 }
17626 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
17627 PyObject *resultobj;
17628 wxScreenDC *result;
17629 char *kwnames[] = {
17630 NULL
17631 };
17632
17633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
17634 {
17635 if (!wxPyCheckForApp()) SWIG_fail;
17636 PyThreadState* __tstate = wxPyBeginAllowThreads();
17637 result = (wxScreenDC *)new wxScreenDC();
17638
17639 wxPyEndAllowThreads(__tstate);
17640 if (PyErr_Occurred()) SWIG_fail;
17641 }
17642 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
17643 return resultobj;
17644 fail:
17645 return NULL;
17646 }
17647
17648
17649 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
17650 PyObject *resultobj;
17651 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17652 wxWindow *arg2 = (wxWindow *) 0 ;
17653 bool result;
17654 PyObject * obj0 = 0 ;
17655 PyObject * obj1 = 0 ;
17656 char *kwnames[] = {
17657 (char *) "self",(char *) "window", NULL
17658 };
17659
17660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
17661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17662 if (SWIG_arg_fail(1)) SWIG_fail;
17663 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17664 if (SWIG_arg_fail(2)) SWIG_fail;
17665 {
17666 PyThreadState* __tstate = wxPyBeginAllowThreads();
17667 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17668
17669 wxPyEndAllowThreads(__tstate);
17670 if (PyErr_Occurred()) SWIG_fail;
17671 }
17672 {
17673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17674 }
17675 return resultobj;
17676 fail:
17677 return NULL;
17678 }
17679
17680
17681 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17682 PyObject *resultobj;
17683 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17684 wxRect *arg2 = (wxRect *) NULL ;
17685 bool result;
17686 PyObject * obj0 = 0 ;
17687 PyObject * obj1 = 0 ;
17688 char *kwnames[] = {
17689 (char *) "self",(char *) "rect", NULL
17690 };
17691
17692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
17693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17694 if (SWIG_arg_fail(1)) SWIG_fail;
17695 if (obj1) {
17696 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
17697 if (SWIG_arg_fail(2)) SWIG_fail;
17698 }
17699 {
17700 PyThreadState* __tstate = wxPyBeginAllowThreads();
17701 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17702
17703 wxPyEndAllowThreads(__tstate);
17704 if (PyErr_Occurred()) SWIG_fail;
17705 }
17706 {
17707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17708 }
17709 return resultobj;
17710 fail:
17711 return NULL;
17712 }
17713
17714
17715 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17716 PyObject *resultobj;
17717 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17718 bool result;
17719 PyObject * obj0 = 0 ;
17720 char *kwnames[] = {
17721 (char *) "self", NULL
17722 };
17723
17724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
17725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17726 if (SWIG_arg_fail(1)) SWIG_fail;
17727 {
17728 PyThreadState* __tstate = wxPyBeginAllowThreads();
17729 result = (bool)(arg1)->EndDrawingOnTop();
17730
17731 wxPyEndAllowThreads(__tstate);
17732 if (PyErr_Occurred()) SWIG_fail;
17733 }
17734 {
17735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17736 }
17737 return resultobj;
17738 fail:
17739 return NULL;
17740 }
17741
17742
17743 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
17744 PyObject *obj;
17745 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17746 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
17747 Py_INCREF(obj);
17748 return Py_BuildValue((char *)"");
17749 }
17750 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
17751 PyObject *resultobj;
17752 wxWindow *arg1 = (wxWindow *) 0 ;
17753 wxClientDC *result;
17754 PyObject * obj0 = 0 ;
17755 char *kwnames[] = {
17756 (char *) "win", NULL
17757 };
17758
17759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
17760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17761 if (SWIG_arg_fail(1)) SWIG_fail;
17762 {
17763 if (!wxPyCheckForApp()) SWIG_fail;
17764 PyThreadState* __tstate = wxPyBeginAllowThreads();
17765 result = (wxClientDC *)new wxClientDC(arg1);
17766
17767 wxPyEndAllowThreads(__tstate);
17768 if (PyErr_Occurred()) SWIG_fail;
17769 }
17770 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
17771 return resultobj;
17772 fail:
17773 return NULL;
17774 }
17775
17776
17777 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
17778 PyObject *obj;
17779 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17780 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
17781 Py_INCREF(obj);
17782 return Py_BuildValue((char *)"");
17783 }
17784 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17785 PyObject *resultobj;
17786 wxWindow *arg1 = (wxWindow *) 0 ;
17787 wxPaintDC *result;
17788 PyObject * obj0 = 0 ;
17789 char *kwnames[] = {
17790 (char *) "win", NULL
17791 };
17792
17793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
17794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17795 if (SWIG_arg_fail(1)) SWIG_fail;
17796 {
17797 if (!wxPyCheckForApp()) SWIG_fail;
17798 PyThreadState* __tstate = wxPyBeginAllowThreads();
17799 result = (wxPaintDC *)new wxPaintDC(arg1);
17800
17801 wxPyEndAllowThreads(__tstate);
17802 if (PyErr_Occurred()) SWIG_fail;
17803 }
17804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
17805 return resultobj;
17806 fail:
17807 return NULL;
17808 }
17809
17810
17811 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
17812 PyObject *obj;
17813 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17814 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
17815 Py_INCREF(obj);
17816 return Py_BuildValue((char *)"");
17817 }
17818 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
17819 PyObject *resultobj;
17820 wxWindow *arg1 = (wxWindow *) 0 ;
17821 wxWindowDC *result;
17822 PyObject * obj0 = 0 ;
17823 char *kwnames[] = {
17824 (char *) "win", NULL
17825 };
17826
17827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
17828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17829 if (SWIG_arg_fail(1)) SWIG_fail;
17830 {
17831 if (!wxPyCheckForApp()) SWIG_fail;
17832 PyThreadState* __tstate = wxPyBeginAllowThreads();
17833 result = (wxWindowDC *)new wxWindowDC(arg1);
17834
17835 wxPyEndAllowThreads(__tstate);
17836 if (PyErr_Occurred()) SWIG_fail;
17837 }
17838 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
17839 return resultobj;
17840 fail:
17841 return NULL;
17842 }
17843
17844
17845 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
17846 PyObject *obj;
17847 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17848 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
17849 Py_INCREF(obj);
17850 return Py_BuildValue((char *)"");
17851 }
17852 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
17853 PyObject *resultobj;
17854 wxDC *arg1 = 0 ;
17855 bool arg2 ;
17856 wxMirrorDC *result;
17857 PyObject * obj0 = 0 ;
17858 PyObject * obj1 = 0 ;
17859 char *kwnames[] = {
17860 (char *) "dc",(char *) "mirror", NULL
17861 };
17862
17863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
17864 {
17865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17866 if (SWIG_arg_fail(1)) SWIG_fail;
17867 if (arg1 == NULL) {
17868 SWIG_null_ref("wxDC");
17869 }
17870 if (SWIG_arg_fail(1)) SWIG_fail;
17871 }
17872 {
17873 arg2 = (bool)(SWIG_As_bool(obj1));
17874 if (SWIG_arg_fail(2)) SWIG_fail;
17875 }
17876 {
17877 if (!wxPyCheckForApp()) SWIG_fail;
17878 PyThreadState* __tstate = wxPyBeginAllowThreads();
17879 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
17880
17881 wxPyEndAllowThreads(__tstate);
17882 if (PyErr_Occurred()) SWIG_fail;
17883 }
17884 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
17885 return resultobj;
17886 fail:
17887 return NULL;
17888 }
17889
17890
17891 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
17892 PyObject *obj;
17893 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17894 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
17895 Py_INCREF(obj);
17896 return Py_BuildValue((char *)"");
17897 }
17898 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
17899 PyObject *resultobj;
17900 wxPrintData *arg1 = 0 ;
17901 wxPostScriptDC *result;
17902 PyObject * obj0 = 0 ;
17903 char *kwnames[] = {
17904 (char *) "printData", NULL
17905 };
17906
17907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
17908 {
17909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17910 if (SWIG_arg_fail(1)) SWIG_fail;
17911 if (arg1 == NULL) {
17912 SWIG_null_ref("wxPrintData");
17913 }
17914 if (SWIG_arg_fail(1)) SWIG_fail;
17915 }
17916 {
17917 if (!wxPyCheckForApp()) SWIG_fail;
17918 PyThreadState* __tstate = wxPyBeginAllowThreads();
17919 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
17920
17921 wxPyEndAllowThreads(__tstate);
17922 if (PyErr_Occurred()) SWIG_fail;
17923 }
17924 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
17925 return resultobj;
17926 fail:
17927 return NULL;
17928 }
17929
17930
17931 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17932 PyObject *resultobj;
17933 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17934 wxPrintData *result;
17935 PyObject * obj0 = 0 ;
17936 char *kwnames[] = {
17937 (char *) "self", NULL
17938 };
17939
17940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
17941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17942 if (SWIG_arg_fail(1)) SWIG_fail;
17943 {
17944 PyThreadState* __tstate = wxPyBeginAllowThreads();
17945 {
17946 wxPrintData &_result_ref = (arg1)->GetPrintData();
17947 result = (wxPrintData *) &_result_ref;
17948 }
17949
17950 wxPyEndAllowThreads(__tstate);
17951 if (PyErr_Occurred()) SWIG_fail;
17952 }
17953 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
17954 return resultobj;
17955 fail:
17956 return NULL;
17957 }
17958
17959
17960 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17961 PyObject *resultobj;
17962 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17963 wxPrintData *arg2 = 0 ;
17964 PyObject * obj0 = 0 ;
17965 PyObject * obj1 = 0 ;
17966 char *kwnames[] = {
17967 (char *) "self",(char *) "data", NULL
17968 };
17969
17970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
17971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17972 if (SWIG_arg_fail(1)) SWIG_fail;
17973 {
17974 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17975 if (SWIG_arg_fail(2)) SWIG_fail;
17976 if (arg2 == NULL) {
17977 SWIG_null_ref("wxPrintData");
17978 }
17979 if (SWIG_arg_fail(2)) SWIG_fail;
17980 }
17981 {
17982 PyThreadState* __tstate = wxPyBeginAllowThreads();
17983 (arg1)->SetPrintData((wxPrintData const &)*arg2);
17984
17985 wxPyEndAllowThreads(__tstate);
17986 if (PyErr_Occurred()) SWIG_fail;
17987 }
17988 Py_INCREF(Py_None); resultobj = Py_None;
17989 return resultobj;
17990 fail:
17991 return NULL;
17992 }
17993
17994
17995 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17996 PyObject *resultobj;
17997 int arg1 ;
17998 PyObject * obj0 = 0 ;
17999 char *kwnames[] = {
18000 (char *) "ppi", NULL
18001 };
18002
18003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
18004 {
18005 arg1 = (int)(SWIG_As_int(obj0));
18006 if (SWIG_arg_fail(1)) SWIG_fail;
18007 }
18008 {
18009 PyThreadState* __tstate = wxPyBeginAllowThreads();
18010 wxPostScriptDC::SetResolution(arg1);
18011
18012 wxPyEndAllowThreads(__tstate);
18013 if (PyErr_Occurred()) SWIG_fail;
18014 }
18015 Py_INCREF(Py_None); resultobj = Py_None;
18016 return resultobj;
18017 fail:
18018 return NULL;
18019 }
18020
18021
18022 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
18023 PyObject *resultobj;
18024 int result;
18025 char *kwnames[] = {
18026 NULL
18027 };
18028
18029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
18030 {
18031 PyThreadState* __tstate = wxPyBeginAllowThreads();
18032 result = (int)wxPostScriptDC::GetResolution();
18033
18034 wxPyEndAllowThreads(__tstate);
18035 if (PyErr_Occurred()) SWIG_fail;
18036 }
18037 {
18038 resultobj = SWIG_From_int((int)(result));
18039 }
18040 return resultobj;
18041 fail:
18042 return NULL;
18043 }
18044
18045
18046 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
18047 PyObject *obj;
18048 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18049 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
18050 Py_INCREF(obj);
18051 return Py_BuildValue((char *)"");
18052 }
18053 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18054 PyObject *resultobj;
18055 wxString const &arg1_defvalue = wxPyEmptyString ;
18056 wxString *arg1 = (wxString *) &arg1_defvalue ;
18057 wxMetaFile *result;
18058 bool temp1 = false ;
18059 PyObject * obj0 = 0 ;
18060 char *kwnames[] = {
18061 (char *) "filename", NULL
18062 };
18063
18064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
18065 if (obj0) {
18066 {
18067 arg1 = wxString_in_helper(obj0);
18068 if (arg1 == NULL) SWIG_fail;
18069 temp1 = true;
18070 }
18071 }
18072 {
18073 if (!wxPyCheckForApp()) SWIG_fail;
18074 PyThreadState* __tstate = wxPyBeginAllowThreads();
18075 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
18076
18077 wxPyEndAllowThreads(__tstate);
18078 if (PyErr_Occurred()) SWIG_fail;
18079 }
18080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
18081 {
18082 if (temp1)
18083 delete arg1;
18084 }
18085 return resultobj;
18086 fail:
18087 {
18088 if (temp1)
18089 delete arg1;
18090 }
18091 return NULL;
18092 }
18093
18094
18095 static PyObject *_wrap_delete_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18096 PyObject *resultobj;
18097 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18098 PyObject * obj0 = 0 ;
18099 char *kwnames[] = {
18100 (char *) "self", NULL
18101 };
18102
18103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MetaFile",kwnames,&obj0)) goto fail;
18104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18105 if (SWIG_arg_fail(1)) SWIG_fail;
18106 {
18107 PyThreadState* __tstate = wxPyBeginAllowThreads();
18108 delete arg1;
18109
18110 wxPyEndAllowThreads(__tstate);
18111 if (PyErr_Occurred()) SWIG_fail;
18112 }
18113 Py_INCREF(Py_None); resultobj = Py_None;
18114 return resultobj;
18115 fail:
18116 return NULL;
18117 }
18118
18119
18120 static PyObject *_wrap_MetaFile_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
18121 PyObject *resultobj;
18122 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18123 bool result;
18124 PyObject * obj0 = 0 ;
18125 char *kwnames[] = {
18126 (char *) "self", NULL
18127 };
18128
18129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_Ok",kwnames,&obj0)) goto fail;
18130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18131 if (SWIG_arg_fail(1)) SWIG_fail;
18132 {
18133 PyThreadState* __tstate = wxPyBeginAllowThreads();
18134 result = (bool)(arg1)->Ok();
18135
18136 wxPyEndAllowThreads(__tstate);
18137 if (PyErr_Occurred()) SWIG_fail;
18138 }
18139 {
18140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18141 }
18142 return resultobj;
18143 fail:
18144 return NULL;
18145 }
18146
18147
18148 static PyObject *_wrap_MetaFile_SetClipboard(PyObject *, PyObject *args, PyObject *kwargs) {
18149 PyObject *resultobj;
18150 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18151 int arg2 = (int) 0 ;
18152 int arg3 = (int) 0 ;
18153 bool result;
18154 PyObject * obj0 = 0 ;
18155 PyObject * obj1 = 0 ;
18156 PyObject * obj2 = 0 ;
18157 char *kwnames[] = {
18158 (char *) "self",(char *) "width",(char *) "height", NULL
18159 };
18160
18161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MetaFile_SetClipboard",kwnames,&obj0,&obj1,&obj2)) goto fail;
18162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18163 if (SWIG_arg_fail(1)) SWIG_fail;
18164 if (obj1) {
18165 {
18166 arg2 = (int)(SWIG_As_int(obj1));
18167 if (SWIG_arg_fail(2)) SWIG_fail;
18168 }
18169 }
18170 if (obj2) {
18171 {
18172 arg3 = (int)(SWIG_As_int(obj2));
18173 if (SWIG_arg_fail(3)) SWIG_fail;
18174 }
18175 }
18176 {
18177 PyThreadState* __tstate = wxPyBeginAllowThreads();
18178 result = (bool)(arg1)->SetClipboard(arg2,arg3);
18179
18180 wxPyEndAllowThreads(__tstate);
18181 if (PyErr_Occurred()) SWIG_fail;
18182 }
18183 {
18184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18185 }
18186 return resultobj;
18187 fail:
18188 return NULL;
18189 }
18190
18191
18192 static PyObject *_wrap_MetaFile_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18193 PyObject *resultobj;
18194 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18195 wxSize result;
18196 PyObject * obj0 = 0 ;
18197 char *kwnames[] = {
18198 (char *) "self", NULL
18199 };
18200
18201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetSize",kwnames,&obj0)) goto fail;
18202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18203 if (SWIG_arg_fail(1)) SWIG_fail;
18204 {
18205 PyThreadState* __tstate = wxPyBeginAllowThreads();
18206 result = (arg1)->GetSize();
18207
18208 wxPyEndAllowThreads(__tstate);
18209 if (PyErr_Occurred()) SWIG_fail;
18210 }
18211 {
18212 wxSize * resultptr;
18213 resultptr = new wxSize((wxSize &)(result));
18214 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18215 }
18216 return resultobj;
18217 fail:
18218 return NULL;
18219 }
18220
18221
18222 static PyObject *_wrap_MetaFile_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
18223 PyObject *resultobj;
18224 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18225 int result;
18226 PyObject * obj0 = 0 ;
18227 char *kwnames[] = {
18228 (char *) "self", NULL
18229 };
18230
18231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetWidth",kwnames,&obj0)) goto fail;
18232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18233 if (SWIG_arg_fail(1)) SWIG_fail;
18234 {
18235 PyThreadState* __tstate = wxPyBeginAllowThreads();
18236 result = (int)(arg1)->GetWidth();
18237
18238 wxPyEndAllowThreads(__tstate);
18239 if (PyErr_Occurred()) SWIG_fail;
18240 }
18241 {
18242 resultobj = SWIG_From_int((int)(result));
18243 }
18244 return resultobj;
18245 fail:
18246 return NULL;
18247 }
18248
18249
18250 static PyObject *_wrap_MetaFile_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
18251 PyObject *resultobj;
18252 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18253 int result;
18254 PyObject * obj0 = 0 ;
18255 char *kwnames[] = {
18256 (char *) "self", NULL
18257 };
18258
18259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetHeight",kwnames,&obj0)) goto fail;
18260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18261 if (SWIG_arg_fail(1)) SWIG_fail;
18262 {
18263 PyThreadState* __tstate = wxPyBeginAllowThreads();
18264 result = (int)(arg1)->GetHeight();
18265
18266 wxPyEndAllowThreads(__tstate);
18267 if (PyErr_Occurred()) SWIG_fail;
18268 }
18269 {
18270 resultobj = SWIG_From_int((int)(result));
18271 }
18272 return resultobj;
18273 fail:
18274 return NULL;
18275 }
18276
18277
18278 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
18279 PyObject *obj;
18280 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18281 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
18282 Py_INCREF(obj);
18283 return Py_BuildValue((char *)"");
18284 }
18285 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
18286 PyObject *resultobj;
18287 wxString const &arg1_defvalue = wxPyEmptyString ;
18288 wxString *arg1 = (wxString *) &arg1_defvalue ;
18289 int arg2 = (int) 0 ;
18290 int arg3 = (int) 0 ;
18291 wxString const &arg4_defvalue = wxPyEmptyString ;
18292 wxString *arg4 = (wxString *) &arg4_defvalue ;
18293 wxMetaFileDC *result;
18294 bool temp1 = false ;
18295 bool temp4 = false ;
18296 PyObject * obj0 = 0 ;
18297 PyObject * obj1 = 0 ;
18298 PyObject * obj2 = 0 ;
18299 PyObject * obj3 = 0 ;
18300 char *kwnames[] = {
18301 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
18302 };
18303
18304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18305 if (obj0) {
18306 {
18307 arg1 = wxString_in_helper(obj0);
18308 if (arg1 == NULL) SWIG_fail;
18309 temp1 = true;
18310 }
18311 }
18312 if (obj1) {
18313 {
18314 arg2 = (int)(SWIG_As_int(obj1));
18315 if (SWIG_arg_fail(2)) SWIG_fail;
18316 }
18317 }
18318 if (obj2) {
18319 {
18320 arg3 = (int)(SWIG_As_int(obj2));
18321 if (SWIG_arg_fail(3)) SWIG_fail;
18322 }
18323 }
18324 if (obj3) {
18325 {
18326 arg4 = wxString_in_helper(obj3);
18327 if (arg4 == NULL) SWIG_fail;
18328 temp4 = true;
18329 }
18330 }
18331 {
18332 if (!wxPyCheckForApp()) SWIG_fail;
18333 PyThreadState* __tstate = wxPyBeginAllowThreads();
18334 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
18335
18336 wxPyEndAllowThreads(__tstate);
18337 if (PyErr_Occurred()) SWIG_fail;
18338 }
18339 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
18340 {
18341 if (temp1)
18342 delete arg1;
18343 }
18344 {
18345 if (temp4)
18346 delete arg4;
18347 }
18348 return resultobj;
18349 fail:
18350 {
18351 if (temp1)
18352 delete arg1;
18353 }
18354 {
18355 if (temp4)
18356 delete arg4;
18357 }
18358 return NULL;
18359 }
18360
18361
18362 static PyObject *_wrap_MetaFileDC_Close(PyObject *, PyObject *args, PyObject *kwargs) {
18363 PyObject *resultobj;
18364 wxMetaFileDC *arg1 = (wxMetaFileDC *) 0 ;
18365 wxMetaFile *result;
18366 PyObject * obj0 = 0 ;
18367 char *kwnames[] = {
18368 (char *) "self", NULL
18369 };
18370
18371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFileDC_Close",kwnames,&obj0)) goto fail;
18372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFileDC, SWIG_POINTER_EXCEPTION | 0);
18373 if (SWIG_arg_fail(1)) SWIG_fail;
18374 {
18375 PyThreadState* __tstate = wxPyBeginAllowThreads();
18376 result = (wxMetaFile *)(arg1)->Close();
18377
18378 wxPyEndAllowThreads(__tstate);
18379 if (PyErr_Occurred()) SWIG_fail;
18380 }
18381 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 0);
18382 return resultobj;
18383 fail:
18384 return NULL;
18385 }
18386
18387
18388 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
18389 PyObject *obj;
18390 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18391 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
18392 Py_INCREF(obj);
18393 return Py_BuildValue((char *)"");
18394 }
18395 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
18396 PyObject *resultobj;
18397 wxPrintData *arg1 = 0 ;
18398 wxPrinterDC *result;
18399 PyObject * obj0 = 0 ;
18400 char *kwnames[] = {
18401 (char *) "printData", NULL
18402 };
18403
18404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
18405 {
18406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18407 if (SWIG_arg_fail(1)) SWIG_fail;
18408 if (arg1 == NULL) {
18409 SWIG_null_ref("wxPrintData");
18410 }
18411 if (SWIG_arg_fail(1)) SWIG_fail;
18412 }
18413 {
18414 if (!wxPyCheckForApp()) SWIG_fail;
18415 PyThreadState* __tstate = wxPyBeginAllowThreads();
18416 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
18417
18418 wxPyEndAllowThreads(__tstate);
18419 if (PyErr_Occurred()) SWIG_fail;
18420 }
18421 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
18422 return resultobj;
18423 fail:
18424 return NULL;
18425 }
18426
18427
18428 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
18429 PyObject *obj;
18430 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18431 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
18432 Py_INCREF(obj);
18433 return Py_BuildValue((char *)"");
18434 }
18435 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18436 PyObject *resultobj;
18437 int arg1 ;
18438 int arg2 ;
18439 int arg3 = (int) true ;
18440 int arg4 = (int) 1 ;
18441 wxImageList *result;
18442 PyObject * obj0 = 0 ;
18443 PyObject * obj1 = 0 ;
18444 PyObject * obj2 = 0 ;
18445 PyObject * obj3 = 0 ;
18446 char *kwnames[] = {
18447 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
18448 };
18449
18450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18451 {
18452 arg1 = (int)(SWIG_As_int(obj0));
18453 if (SWIG_arg_fail(1)) SWIG_fail;
18454 }
18455 {
18456 arg2 = (int)(SWIG_As_int(obj1));
18457 if (SWIG_arg_fail(2)) SWIG_fail;
18458 }
18459 if (obj2) {
18460 {
18461 arg3 = (int)(SWIG_As_int(obj2));
18462 if (SWIG_arg_fail(3)) SWIG_fail;
18463 }
18464 }
18465 if (obj3) {
18466 {
18467 arg4 = (int)(SWIG_As_int(obj3));
18468 if (SWIG_arg_fail(4)) SWIG_fail;
18469 }
18470 }
18471 {
18472 if (!wxPyCheckForApp()) SWIG_fail;
18473 PyThreadState* __tstate = wxPyBeginAllowThreads();
18474 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
18475
18476 wxPyEndAllowThreads(__tstate);
18477 if (PyErr_Occurred()) SWIG_fail;
18478 }
18479 {
18480 resultobj = wxPyMake_wxObject(result, 1);
18481 }
18482 return resultobj;
18483 fail:
18484 return NULL;
18485 }
18486
18487
18488 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18489 PyObject *resultobj;
18490 wxImageList *arg1 = (wxImageList *) 0 ;
18491 PyObject * obj0 = 0 ;
18492 char *kwnames[] = {
18493 (char *) "self", NULL
18494 };
18495
18496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
18497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18498 if (SWIG_arg_fail(1)) SWIG_fail;
18499 {
18500 PyThreadState* __tstate = wxPyBeginAllowThreads();
18501 delete arg1;
18502
18503 wxPyEndAllowThreads(__tstate);
18504 if (PyErr_Occurred()) SWIG_fail;
18505 }
18506 Py_INCREF(Py_None); resultobj = Py_None;
18507 return resultobj;
18508 fail:
18509 return NULL;
18510 }
18511
18512
18513 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
18514 PyObject *resultobj;
18515 wxImageList *arg1 = (wxImageList *) 0 ;
18516 wxBitmap *arg2 = 0 ;
18517 wxBitmap const &arg3_defvalue = wxNullBitmap ;
18518 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
18519 int result;
18520 PyObject * obj0 = 0 ;
18521 PyObject * obj1 = 0 ;
18522 PyObject * obj2 = 0 ;
18523 char *kwnames[] = {
18524 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
18525 };
18526
18527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
18528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18529 if (SWIG_arg_fail(1)) SWIG_fail;
18530 {
18531 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18532 if (SWIG_arg_fail(2)) SWIG_fail;
18533 if (arg2 == NULL) {
18534 SWIG_null_ref("wxBitmap");
18535 }
18536 if (SWIG_arg_fail(2)) SWIG_fail;
18537 }
18538 if (obj2) {
18539 {
18540 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18541 if (SWIG_arg_fail(3)) SWIG_fail;
18542 if (arg3 == NULL) {
18543 SWIG_null_ref("wxBitmap");
18544 }
18545 if (SWIG_arg_fail(3)) SWIG_fail;
18546 }
18547 }
18548 {
18549 PyThreadState* __tstate = wxPyBeginAllowThreads();
18550 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
18551
18552 wxPyEndAllowThreads(__tstate);
18553 if (PyErr_Occurred()) SWIG_fail;
18554 }
18555 {
18556 resultobj = SWIG_From_int((int)(result));
18557 }
18558 return resultobj;
18559 fail:
18560 return NULL;
18561 }
18562
18563
18564 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
18565 PyObject *resultobj;
18566 wxImageList *arg1 = (wxImageList *) 0 ;
18567 wxBitmap *arg2 = 0 ;
18568 wxColour *arg3 = 0 ;
18569 int result;
18570 wxColour temp3 ;
18571 PyObject * obj0 = 0 ;
18572 PyObject * obj1 = 0 ;
18573 PyObject * obj2 = 0 ;
18574 char *kwnames[] = {
18575 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
18576 };
18577
18578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
18579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18580 if (SWIG_arg_fail(1)) SWIG_fail;
18581 {
18582 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18583 if (SWIG_arg_fail(2)) SWIG_fail;
18584 if (arg2 == NULL) {
18585 SWIG_null_ref("wxBitmap");
18586 }
18587 if (SWIG_arg_fail(2)) SWIG_fail;
18588 }
18589 {
18590 arg3 = &temp3;
18591 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
18592 }
18593 {
18594 PyThreadState* __tstate = wxPyBeginAllowThreads();
18595 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
18596
18597 wxPyEndAllowThreads(__tstate);
18598 if (PyErr_Occurred()) SWIG_fail;
18599 }
18600 {
18601 resultobj = SWIG_From_int((int)(result));
18602 }
18603 return resultobj;
18604 fail:
18605 return NULL;
18606 }
18607
18608
18609 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18610 PyObject *resultobj;
18611 wxImageList *arg1 = (wxImageList *) 0 ;
18612 wxIcon *arg2 = 0 ;
18613 int result;
18614 PyObject * obj0 = 0 ;
18615 PyObject * obj1 = 0 ;
18616 char *kwnames[] = {
18617 (char *) "self",(char *) "icon", NULL
18618 };
18619
18620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
18621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18622 if (SWIG_arg_fail(1)) SWIG_fail;
18623 {
18624 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
18625 if (SWIG_arg_fail(2)) SWIG_fail;
18626 if (arg2 == NULL) {
18627 SWIG_null_ref("wxIcon");
18628 }
18629 if (SWIG_arg_fail(2)) SWIG_fail;
18630 }
18631 {
18632 PyThreadState* __tstate = wxPyBeginAllowThreads();
18633 result = (int)(arg1)->Add((wxIcon const &)*arg2);
18634
18635 wxPyEndAllowThreads(__tstate);
18636 if (PyErr_Occurred()) SWIG_fail;
18637 }
18638 {
18639 resultobj = SWIG_From_int((int)(result));
18640 }
18641 return resultobj;
18642 fail:
18643 return NULL;
18644 }
18645
18646
18647 static PyObject *_wrap_ImageList_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
18648 PyObject *resultobj;
18649 wxImageList *arg1 = (wxImageList *) 0 ;
18650 int arg2 ;
18651 SwigValueWrapper<wxBitmap > result;
18652 PyObject * obj0 = 0 ;
18653 PyObject * obj1 = 0 ;
18654 char *kwnames[] = {
18655 (char *) "self",(char *) "index", NULL
18656 };
18657
18658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) goto fail;
18659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18660 if (SWIG_arg_fail(1)) SWIG_fail;
18661 {
18662 arg2 = (int)(SWIG_As_int(obj1));
18663 if (SWIG_arg_fail(2)) SWIG_fail;
18664 }
18665 {
18666 PyThreadState* __tstate = wxPyBeginAllowThreads();
18667 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
18668
18669 wxPyEndAllowThreads(__tstate);
18670 if (PyErr_Occurred()) SWIG_fail;
18671 }
18672 {
18673 wxBitmap * resultptr;
18674 resultptr = new wxBitmap((wxBitmap &)(result));
18675 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
18676 }
18677 return resultobj;
18678 fail:
18679 return NULL;
18680 }
18681
18682
18683 static PyObject *_wrap_ImageList_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18684 PyObject *resultobj;
18685 wxImageList *arg1 = (wxImageList *) 0 ;
18686 int arg2 ;
18687 wxIcon result;
18688 PyObject * obj0 = 0 ;
18689 PyObject * obj1 = 0 ;
18690 char *kwnames[] = {
18691 (char *) "self",(char *) "index", NULL
18692 };
18693
18694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) goto fail;
18695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18696 if (SWIG_arg_fail(1)) SWIG_fail;
18697 {
18698 arg2 = (int)(SWIG_As_int(obj1));
18699 if (SWIG_arg_fail(2)) SWIG_fail;
18700 }
18701 {
18702 PyThreadState* __tstate = wxPyBeginAllowThreads();
18703 result = ((wxImageList const *)arg1)->GetIcon(arg2);
18704
18705 wxPyEndAllowThreads(__tstate);
18706 if (PyErr_Occurred()) SWIG_fail;
18707 }
18708 {
18709 wxIcon * resultptr;
18710 resultptr = new wxIcon((wxIcon &)(result));
18711 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
18712 }
18713 return resultobj;
18714 fail:
18715 return NULL;
18716 }
18717
18718
18719 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
18720 PyObject *resultobj;
18721 wxImageList *arg1 = (wxImageList *) 0 ;
18722 int arg2 ;
18723 wxBitmap *arg3 = 0 ;
18724 bool result;
18725 PyObject * obj0 = 0 ;
18726 PyObject * obj1 = 0 ;
18727 PyObject * obj2 = 0 ;
18728 char *kwnames[] = {
18729 (char *) "self",(char *) "index",(char *) "bitmap", NULL
18730 };
18731
18732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_Replace",kwnames,&obj0,&obj1,&obj2)) goto fail;
18733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18734 if (SWIG_arg_fail(1)) SWIG_fail;
18735 {
18736 arg2 = (int)(SWIG_As_int(obj1));
18737 if (SWIG_arg_fail(2)) SWIG_fail;
18738 }
18739 {
18740 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18741 if (SWIG_arg_fail(3)) SWIG_fail;
18742 if (arg3 == NULL) {
18743 SWIG_null_ref("wxBitmap");
18744 }
18745 if (SWIG_arg_fail(3)) SWIG_fail;
18746 }
18747 {
18748 PyThreadState* __tstate = wxPyBeginAllowThreads();
18749 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3);
18750
18751 wxPyEndAllowThreads(__tstate);
18752 if (PyErr_Occurred()) SWIG_fail;
18753 }
18754 {
18755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18756 }
18757 return resultobj;
18758 fail:
18759 return NULL;
18760 }
18761
18762
18763 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
18764 PyObject *resultobj;
18765 wxImageList *arg1 = (wxImageList *) 0 ;
18766 int arg2 ;
18767 wxDC *arg3 = 0 ;
18768 int arg4 ;
18769 int arg5 ;
18770 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
18771 bool arg7 = (bool) (bool)false ;
18772 bool result;
18773 PyObject * obj0 = 0 ;
18774 PyObject * obj1 = 0 ;
18775 PyObject * obj2 = 0 ;
18776 PyObject * obj3 = 0 ;
18777 PyObject * obj4 = 0 ;
18778 PyObject * obj5 = 0 ;
18779 PyObject * obj6 = 0 ;
18780 char *kwnames[] = {
18781 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
18782 };
18783
18784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
18785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18786 if (SWIG_arg_fail(1)) SWIG_fail;
18787 {
18788 arg2 = (int)(SWIG_As_int(obj1));
18789 if (SWIG_arg_fail(2)) SWIG_fail;
18790 }
18791 {
18792 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18793 if (SWIG_arg_fail(3)) SWIG_fail;
18794 if (arg3 == NULL) {
18795 SWIG_null_ref("wxDC");
18796 }
18797 if (SWIG_arg_fail(3)) SWIG_fail;
18798 }
18799 {
18800 arg4 = (int)(SWIG_As_int(obj3));
18801 if (SWIG_arg_fail(4)) SWIG_fail;
18802 }
18803 {
18804 arg5 = (int)(SWIG_As_int(obj4));
18805 if (SWIG_arg_fail(5)) SWIG_fail;
18806 }
18807 if (obj5) {
18808 {
18809 arg6 = (int)(SWIG_As_int(obj5));
18810 if (SWIG_arg_fail(6)) SWIG_fail;
18811 }
18812 }
18813 if (obj6) {
18814 {
18815 arg7 = (bool const)(SWIG_As_bool(obj6));
18816 if (SWIG_arg_fail(7)) SWIG_fail;
18817 }
18818 }
18819 {
18820 PyThreadState* __tstate = wxPyBeginAllowThreads();
18821 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
18822
18823 wxPyEndAllowThreads(__tstate);
18824 if (PyErr_Occurred()) SWIG_fail;
18825 }
18826 {
18827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18828 }
18829 return resultobj;
18830 fail:
18831 return NULL;
18832 }
18833
18834
18835 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
18836 PyObject *resultobj;
18837 wxImageList *arg1 = (wxImageList *) 0 ;
18838 int result;
18839 PyObject * obj0 = 0 ;
18840 char *kwnames[] = {
18841 (char *) "self", NULL
18842 };
18843
18844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
18845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18846 if (SWIG_arg_fail(1)) SWIG_fail;
18847 {
18848 PyThreadState* __tstate = wxPyBeginAllowThreads();
18849 result = (int)(arg1)->GetImageCount();
18850
18851 wxPyEndAllowThreads(__tstate);
18852 if (PyErr_Occurred()) SWIG_fail;
18853 }
18854 {
18855 resultobj = SWIG_From_int((int)(result));
18856 }
18857 return resultobj;
18858 fail:
18859 return NULL;
18860 }
18861
18862
18863 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
18864 PyObject *resultobj;
18865 wxImageList *arg1 = (wxImageList *) 0 ;
18866 int arg2 ;
18867 bool result;
18868 PyObject * obj0 = 0 ;
18869 PyObject * obj1 = 0 ;
18870 char *kwnames[] = {
18871 (char *) "self",(char *) "index", NULL
18872 };
18873
18874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
18875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18876 if (SWIG_arg_fail(1)) SWIG_fail;
18877 {
18878 arg2 = (int)(SWIG_As_int(obj1));
18879 if (SWIG_arg_fail(2)) SWIG_fail;
18880 }
18881 {
18882 PyThreadState* __tstate = wxPyBeginAllowThreads();
18883 result = (bool)(arg1)->Remove(arg2);
18884
18885 wxPyEndAllowThreads(__tstate);
18886 if (PyErr_Occurred()) SWIG_fail;
18887 }
18888 {
18889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18890 }
18891 return resultobj;
18892 fail:
18893 return NULL;
18894 }
18895
18896
18897 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
18898 PyObject *resultobj;
18899 wxImageList *arg1 = (wxImageList *) 0 ;
18900 bool result;
18901 PyObject * obj0 = 0 ;
18902 char *kwnames[] = {
18903 (char *) "self", NULL
18904 };
18905
18906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
18907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18908 if (SWIG_arg_fail(1)) SWIG_fail;
18909 {
18910 PyThreadState* __tstate = wxPyBeginAllowThreads();
18911 result = (bool)(arg1)->RemoveAll();
18912
18913 wxPyEndAllowThreads(__tstate);
18914 if (PyErr_Occurred()) SWIG_fail;
18915 }
18916 {
18917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18918 }
18919 return resultobj;
18920 fail:
18921 return NULL;
18922 }
18923
18924
18925 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18926 PyObject *resultobj;
18927 wxImageList *arg1 = (wxImageList *) 0 ;
18928 int arg2 ;
18929 int *arg3 = 0 ;
18930 int *arg4 = 0 ;
18931 int temp3 ;
18932 int res3 = 0 ;
18933 int temp4 ;
18934 int res4 = 0 ;
18935 PyObject * obj0 = 0 ;
18936 PyObject * obj1 = 0 ;
18937 char *kwnames[] = {
18938 (char *) "self",(char *) "index", NULL
18939 };
18940
18941 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18942 arg4 = &temp4; res4 = SWIG_NEWOBJ;
18943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
18944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18945 if (SWIG_arg_fail(1)) SWIG_fail;
18946 {
18947 arg2 = (int)(SWIG_As_int(obj1));
18948 if (SWIG_arg_fail(2)) SWIG_fail;
18949 }
18950 {
18951 PyThreadState* __tstate = wxPyBeginAllowThreads();
18952 (arg1)->GetSize(arg2,*arg3,*arg4);
18953
18954 wxPyEndAllowThreads(__tstate);
18955 if (PyErr_Occurred()) SWIG_fail;
18956 }
18957 Py_INCREF(Py_None); resultobj = Py_None;
18958 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18959 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18960 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
18961 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
18962 return resultobj;
18963 fail:
18964 return NULL;
18965 }
18966
18967
18968 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
18969 PyObject *obj;
18970 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18971 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
18972 Py_INCREF(obj);
18973 return Py_BuildValue((char *)"");
18974 }
18975 static int _wrap_NORMAL_FONT_set(PyObject *) {
18976 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
18977 return 1;
18978 }
18979
18980
18981 static PyObject *_wrap_NORMAL_FONT_get(void) {
18982 PyObject *pyobj;
18983
18984 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
18985 return pyobj;
18986 }
18987
18988
18989 static int _wrap_SMALL_FONT_set(PyObject *) {
18990 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
18991 return 1;
18992 }
18993
18994
18995 static PyObject *_wrap_SMALL_FONT_get(void) {
18996 PyObject *pyobj;
18997
18998 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
18999 return pyobj;
19000 }
19001
19002
19003 static int _wrap_ITALIC_FONT_set(PyObject *) {
19004 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
19005 return 1;
19006 }
19007
19008
19009 static PyObject *_wrap_ITALIC_FONT_get(void) {
19010 PyObject *pyobj;
19011
19012 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
19013 return pyobj;
19014 }
19015
19016
19017 static int _wrap_SWISS_FONT_set(PyObject *) {
19018 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
19019 return 1;
19020 }
19021
19022
19023 static PyObject *_wrap_SWISS_FONT_get(void) {
19024 PyObject *pyobj;
19025
19026 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
19027 return pyobj;
19028 }
19029
19030
19031 static int _wrap_RED_PEN_set(PyObject *) {
19032 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
19033 return 1;
19034 }
19035
19036
19037 static PyObject *_wrap_RED_PEN_get(void) {
19038 PyObject *pyobj;
19039
19040 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
19041 return pyobj;
19042 }
19043
19044
19045 static int _wrap_CYAN_PEN_set(PyObject *) {
19046 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
19047 return 1;
19048 }
19049
19050
19051 static PyObject *_wrap_CYAN_PEN_get(void) {
19052 PyObject *pyobj;
19053
19054 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
19055 return pyobj;
19056 }
19057
19058
19059 static int _wrap_GREEN_PEN_set(PyObject *) {
19060 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
19061 return 1;
19062 }
19063
19064
19065 static PyObject *_wrap_GREEN_PEN_get(void) {
19066 PyObject *pyobj;
19067
19068 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
19069 return pyobj;
19070 }
19071
19072
19073 static int _wrap_BLACK_PEN_set(PyObject *) {
19074 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
19075 return 1;
19076 }
19077
19078
19079 static PyObject *_wrap_BLACK_PEN_get(void) {
19080 PyObject *pyobj;
19081
19082 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
19083 return pyobj;
19084 }
19085
19086
19087 static int _wrap_WHITE_PEN_set(PyObject *) {
19088 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
19089 return 1;
19090 }
19091
19092
19093 static PyObject *_wrap_WHITE_PEN_get(void) {
19094 PyObject *pyobj;
19095
19096 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
19097 return pyobj;
19098 }
19099
19100
19101 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
19102 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
19103 return 1;
19104 }
19105
19106
19107 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
19108 PyObject *pyobj;
19109
19110 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
19111 return pyobj;
19112 }
19113
19114
19115 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
19116 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
19117 return 1;
19118 }
19119
19120
19121 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
19122 PyObject *pyobj;
19123
19124 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
19125 return pyobj;
19126 }
19127
19128
19129 static int _wrap_GREY_PEN_set(PyObject *) {
19130 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
19131 return 1;
19132 }
19133
19134
19135 static PyObject *_wrap_GREY_PEN_get(void) {
19136 PyObject *pyobj;
19137
19138 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
19139 return pyobj;
19140 }
19141
19142
19143 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
19144 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
19145 return 1;
19146 }
19147
19148
19149 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
19150 PyObject *pyobj;
19151
19152 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19153 return pyobj;
19154 }
19155
19156
19157 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
19158 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
19159 return 1;
19160 }
19161
19162
19163 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
19164 PyObject *pyobj;
19165
19166 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19167 return pyobj;
19168 }
19169
19170
19171 static int _wrap_BLUE_BRUSH_set(PyObject *) {
19172 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
19173 return 1;
19174 }
19175
19176
19177 static PyObject *_wrap_BLUE_BRUSH_get(void) {
19178 PyObject *pyobj;
19179
19180 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19181 return pyobj;
19182 }
19183
19184
19185 static int _wrap_GREEN_BRUSH_set(PyObject *) {
19186 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
19187 return 1;
19188 }
19189
19190
19191 static PyObject *_wrap_GREEN_BRUSH_get(void) {
19192 PyObject *pyobj;
19193
19194 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19195 return pyobj;
19196 }
19197
19198
19199 static int _wrap_WHITE_BRUSH_set(PyObject *) {
19200 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
19201 return 1;
19202 }
19203
19204
19205 static PyObject *_wrap_WHITE_BRUSH_get(void) {
19206 PyObject *pyobj;
19207
19208 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19209 return pyobj;
19210 }
19211
19212
19213 static int _wrap_BLACK_BRUSH_set(PyObject *) {
19214 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
19215 return 1;
19216 }
19217
19218
19219 static PyObject *_wrap_BLACK_BRUSH_get(void) {
19220 PyObject *pyobj;
19221
19222 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
19223 return pyobj;
19224 }
19225
19226
19227 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
19228 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
19229 return 1;
19230 }
19231
19232
19233 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
19234 PyObject *pyobj;
19235
19236 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
19237 return pyobj;
19238 }
19239
19240
19241 static int _wrap_CYAN_BRUSH_set(PyObject *) {
19242 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
19243 return 1;
19244 }
19245
19246
19247 static PyObject *_wrap_CYAN_BRUSH_get(void) {
19248 PyObject *pyobj;
19249
19250 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19251 return pyobj;
19252 }
19253
19254
19255 static int _wrap_RED_BRUSH_set(PyObject *) {
19256 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
19257 return 1;
19258 }
19259
19260
19261 static PyObject *_wrap_RED_BRUSH_get(void) {
19262 PyObject *pyobj;
19263
19264 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
19265 return pyobj;
19266 }
19267
19268
19269 static int _wrap_GREY_BRUSH_set(PyObject *) {
19270 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
19271 return 1;
19272 }
19273
19274
19275 static PyObject *_wrap_GREY_BRUSH_get(void) {
19276 PyObject *pyobj;
19277
19278 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19279 return pyobj;
19280 }
19281
19282
19283 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
19284 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
19285 return 1;
19286 }
19287
19288
19289 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
19290 PyObject *pyobj;
19291
19292 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19293 return pyobj;
19294 }
19295
19296
19297 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
19298 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
19299 return 1;
19300 }
19301
19302
19303 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
19304 PyObject *pyobj;
19305
19306 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19307 return pyobj;
19308 }
19309
19310
19311 static int _wrap_BLACK_set(PyObject *) {
19312 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
19313 return 1;
19314 }
19315
19316
19317 static PyObject *_wrap_BLACK_get(void) {
19318 PyObject *pyobj;
19319
19320 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
19321 return pyobj;
19322 }
19323
19324
19325 static int _wrap_WHITE_set(PyObject *) {
19326 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
19327 return 1;
19328 }
19329
19330
19331 static PyObject *_wrap_WHITE_get(void) {
19332 PyObject *pyobj;
19333
19334 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
19335 return pyobj;
19336 }
19337
19338
19339 static int _wrap_RED_set(PyObject *) {
19340 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
19341 return 1;
19342 }
19343
19344
19345 static PyObject *_wrap_RED_get(void) {
19346 PyObject *pyobj;
19347
19348 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
19349 return pyobj;
19350 }
19351
19352
19353 static int _wrap_BLUE_set(PyObject *) {
19354 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
19355 return 1;
19356 }
19357
19358
19359 static PyObject *_wrap_BLUE_get(void) {
19360 PyObject *pyobj;
19361
19362 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
19363 return pyobj;
19364 }
19365
19366
19367 static int _wrap_GREEN_set(PyObject *) {
19368 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
19369 return 1;
19370 }
19371
19372
19373 static PyObject *_wrap_GREEN_get(void) {
19374 PyObject *pyobj;
19375
19376 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
19377 return pyobj;
19378 }
19379
19380
19381 static int _wrap_CYAN_set(PyObject *) {
19382 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
19383 return 1;
19384 }
19385
19386
19387 static PyObject *_wrap_CYAN_get(void) {
19388 PyObject *pyobj;
19389
19390 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
19391 return pyobj;
19392 }
19393
19394
19395 static int _wrap_LIGHT_GREY_set(PyObject *) {
19396 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
19397 return 1;
19398 }
19399
19400
19401 static PyObject *_wrap_LIGHT_GREY_get(void) {
19402 PyObject *pyobj;
19403
19404 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
19405 return pyobj;
19406 }
19407
19408
19409 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
19410 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
19411 return 1;
19412 }
19413
19414
19415 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
19416 PyObject *pyobj;
19417
19418 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
19419 return pyobj;
19420 }
19421
19422
19423 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
19424 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
19425 return 1;
19426 }
19427
19428
19429 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
19430 PyObject *pyobj;
19431
19432 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19433 return pyobj;
19434 }
19435
19436
19437 static int _wrap_CROSS_CURSOR_set(PyObject *) {
19438 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
19439 return 1;
19440 }
19441
19442
19443 static PyObject *_wrap_CROSS_CURSOR_get(void) {
19444 PyObject *pyobj;
19445
19446 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19447 return pyobj;
19448 }
19449
19450
19451 static int _wrap_NullBitmap_set(PyObject *) {
19452 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
19453 return 1;
19454 }
19455
19456
19457 static PyObject *_wrap_NullBitmap_get(void) {
19458 PyObject *pyobj;
19459
19460 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
19461 return pyobj;
19462 }
19463
19464
19465 static int _wrap_NullIcon_set(PyObject *) {
19466 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
19467 return 1;
19468 }
19469
19470
19471 static PyObject *_wrap_NullIcon_get(void) {
19472 PyObject *pyobj;
19473
19474 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
19475 return pyobj;
19476 }
19477
19478
19479 static int _wrap_NullCursor_set(PyObject *) {
19480 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
19481 return 1;
19482 }
19483
19484
19485 static PyObject *_wrap_NullCursor_get(void) {
19486 PyObject *pyobj;
19487
19488 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
19489 return pyobj;
19490 }
19491
19492
19493 static int _wrap_NullPen_set(PyObject *) {
19494 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
19495 return 1;
19496 }
19497
19498
19499 static PyObject *_wrap_NullPen_get(void) {
19500 PyObject *pyobj;
19501
19502 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
19503 return pyobj;
19504 }
19505
19506
19507 static int _wrap_NullBrush_set(PyObject *) {
19508 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
19509 return 1;
19510 }
19511
19512
19513 static PyObject *_wrap_NullBrush_get(void) {
19514 PyObject *pyobj;
19515
19516 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
19517 return pyobj;
19518 }
19519
19520
19521 static int _wrap_NullPalette_set(PyObject *) {
19522 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
19523 return 1;
19524 }
19525
19526
19527 static PyObject *_wrap_NullPalette_get(void) {
19528 PyObject *pyobj;
19529
19530 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
19531 return pyobj;
19532 }
19533
19534
19535 static int _wrap_NullFont_set(PyObject *) {
19536 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
19537 return 1;
19538 }
19539
19540
19541 static PyObject *_wrap_NullFont_get(void) {
19542 PyObject *pyobj;
19543
19544 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
19545 return pyobj;
19546 }
19547
19548
19549 static int _wrap_NullColour_set(PyObject *) {
19550 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
19551 return 1;
19552 }
19553
19554
19555 static PyObject *_wrap_NullColour_get(void) {
19556 PyObject *pyobj;
19557
19558 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
19559 return pyobj;
19560 }
19561
19562
19563 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
19564 PyObject *resultobj;
19565 wxPenList *arg1 = (wxPenList *) 0 ;
19566 wxPen *arg2 = (wxPen *) 0 ;
19567 PyObject * obj0 = 0 ;
19568 PyObject * obj1 = 0 ;
19569 char *kwnames[] = {
19570 (char *) "self",(char *) "pen", NULL
19571 };
19572
19573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
19574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19575 if (SWIG_arg_fail(1)) SWIG_fail;
19576 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19577 if (SWIG_arg_fail(2)) SWIG_fail;
19578 {
19579 PyThreadState* __tstate = wxPyBeginAllowThreads();
19580 (arg1)->AddPen(arg2);
19581
19582 wxPyEndAllowThreads(__tstate);
19583 if (PyErr_Occurred()) SWIG_fail;
19584 }
19585 Py_INCREF(Py_None); resultobj = Py_None;
19586 return resultobj;
19587 fail:
19588 return NULL;
19589 }
19590
19591
19592 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
19593 PyObject *resultobj;
19594 wxPenList *arg1 = (wxPenList *) 0 ;
19595 wxColour *arg2 = 0 ;
19596 int arg3 ;
19597 int arg4 ;
19598 wxPen *result;
19599 wxColour temp2 ;
19600 PyObject * obj0 = 0 ;
19601 PyObject * obj1 = 0 ;
19602 PyObject * obj2 = 0 ;
19603 PyObject * obj3 = 0 ;
19604 char *kwnames[] = {
19605 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
19606 };
19607
19608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19610 if (SWIG_arg_fail(1)) SWIG_fail;
19611 {
19612 arg2 = &temp2;
19613 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19614 }
19615 {
19616 arg3 = (int)(SWIG_As_int(obj2));
19617 if (SWIG_arg_fail(3)) SWIG_fail;
19618 }
19619 {
19620 arg4 = (int)(SWIG_As_int(obj3));
19621 if (SWIG_arg_fail(4)) SWIG_fail;
19622 }
19623 {
19624 PyThreadState* __tstate = wxPyBeginAllowThreads();
19625 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
19626
19627 wxPyEndAllowThreads(__tstate);
19628 if (PyErr_Occurred()) SWIG_fail;
19629 }
19630 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
19631 return resultobj;
19632 fail:
19633 return NULL;
19634 }
19635
19636
19637 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
19638 PyObject *resultobj;
19639 wxPenList *arg1 = (wxPenList *) 0 ;
19640 wxPen *arg2 = (wxPen *) 0 ;
19641 PyObject * obj0 = 0 ;
19642 PyObject * obj1 = 0 ;
19643 char *kwnames[] = {
19644 (char *) "self",(char *) "pen", NULL
19645 };
19646
19647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
19648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19649 if (SWIG_arg_fail(1)) SWIG_fail;
19650 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19651 if (SWIG_arg_fail(2)) SWIG_fail;
19652 {
19653 PyThreadState* __tstate = wxPyBeginAllowThreads();
19654 (arg1)->RemovePen(arg2);
19655
19656 wxPyEndAllowThreads(__tstate);
19657 if (PyErr_Occurred()) SWIG_fail;
19658 }
19659 Py_INCREF(Py_None); resultobj = Py_None;
19660 return resultobj;
19661 fail:
19662 return NULL;
19663 }
19664
19665
19666 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19667 PyObject *resultobj;
19668 wxPenList *arg1 = (wxPenList *) 0 ;
19669 int result;
19670 PyObject * obj0 = 0 ;
19671 char *kwnames[] = {
19672 (char *) "self", NULL
19673 };
19674
19675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
19676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19677 if (SWIG_arg_fail(1)) SWIG_fail;
19678 {
19679 PyThreadState* __tstate = wxPyBeginAllowThreads();
19680 result = (int)(arg1)->GetCount();
19681
19682 wxPyEndAllowThreads(__tstate);
19683 if (PyErr_Occurred()) SWIG_fail;
19684 }
19685 {
19686 resultobj = SWIG_From_int((int)(result));
19687 }
19688 return resultobj;
19689 fail:
19690 return NULL;
19691 }
19692
19693
19694 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
19695 PyObject *obj;
19696 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19697 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
19698 Py_INCREF(obj);
19699 return Py_BuildValue((char *)"");
19700 }
19701 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19702 PyObject *resultobj;
19703 wxBrushList *arg1 = (wxBrushList *) 0 ;
19704 wxBrush *arg2 = (wxBrush *) 0 ;
19705 PyObject * obj0 = 0 ;
19706 PyObject * obj1 = 0 ;
19707 char *kwnames[] = {
19708 (char *) "self",(char *) "brush", NULL
19709 };
19710
19711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
19712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19713 if (SWIG_arg_fail(1)) SWIG_fail;
19714 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19715 if (SWIG_arg_fail(2)) SWIG_fail;
19716 {
19717 PyThreadState* __tstate = wxPyBeginAllowThreads();
19718 (arg1)->AddBrush(arg2);
19719
19720 wxPyEndAllowThreads(__tstate);
19721 if (PyErr_Occurred()) SWIG_fail;
19722 }
19723 Py_INCREF(Py_None); resultobj = Py_None;
19724 return resultobj;
19725 fail:
19726 return NULL;
19727 }
19728
19729
19730 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19731 PyObject *resultobj;
19732 wxBrushList *arg1 = (wxBrushList *) 0 ;
19733 wxColour *arg2 = 0 ;
19734 int arg3 = (int) wxSOLID ;
19735 wxBrush *result;
19736 wxColour temp2 ;
19737 PyObject * obj0 = 0 ;
19738 PyObject * obj1 = 0 ;
19739 PyObject * obj2 = 0 ;
19740 char *kwnames[] = {
19741 (char *) "self",(char *) "colour",(char *) "style", NULL
19742 };
19743
19744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
19745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19746 if (SWIG_arg_fail(1)) SWIG_fail;
19747 {
19748 arg2 = &temp2;
19749 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19750 }
19751 if (obj2) {
19752 {
19753 arg3 = (int)(SWIG_As_int(obj2));
19754 if (SWIG_arg_fail(3)) SWIG_fail;
19755 }
19756 }
19757 {
19758 PyThreadState* __tstate = wxPyBeginAllowThreads();
19759 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
19760
19761 wxPyEndAllowThreads(__tstate);
19762 if (PyErr_Occurred()) SWIG_fail;
19763 }
19764 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
19765 return resultobj;
19766 fail:
19767 return NULL;
19768 }
19769
19770
19771 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19772 PyObject *resultobj;
19773 wxBrushList *arg1 = (wxBrushList *) 0 ;
19774 wxBrush *arg2 = (wxBrush *) 0 ;
19775 PyObject * obj0 = 0 ;
19776 PyObject * obj1 = 0 ;
19777 char *kwnames[] = {
19778 (char *) "self",(char *) "brush", NULL
19779 };
19780
19781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
19782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19783 if (SWIG_arg_fail(1)) SWIG_fail;
19784 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19785 if (SWIG_arg_fail(2)) SWIG_fail;
19786 {
19787 PyThreadState* __tstate = wxPyBeginAllowThreads();
19788 (arg1)->RemoveBrush(arg2);
19789
19790 wxPyEndAllowThreads(__tstate);
19791 if (PyErr_Occurred()) SWIG_fail;
19792 }
19793 Py_INCREF(Py_None); resultobj = Py_None;
19794 return resultobj;
19795 fail:
19796 return NULL;
19797 }
19798
19799
19800 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19801 PyObject *resultobj;
19802 wxBrushList *arg1 = (wxBrushList *) 0 ;
19803 int result;
19804 PyObject * obj0 = 0 ;
19805 char *kwnames[] = {
19806 (char *) "self", NULL
19807 };
19808
19809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
19810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19811 if (SWIG_arg_fail(1)) SWIG_fail;
19812 {
19813 PyThreadState* __tstate = wxPyBeginAllowThreads();
19814 result = (int)(arg1)->GetCount();
19815
19816 wxPyEndAllowThreads(__tstate);
19817 if (PyErr_Occurred()) SWIG_fail;
19818 }
19819 {
19820 resultobj = SWIG_From_int((int)(result));
19821 }
19822 return resultobj;
19823 fail:
19824 return NULL;
19825 }
19826
19827
19828 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
19829 PyObject *obj;
19830 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19831 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
19832 Py_INCREF(obj);
19833 return Py_BuildValue((char *)"");
19834 }
19835 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19836 PyObject *resultobj;
19837 wxColourDatabase *result;
19838 char *kwnames[] = {
19839 NULL
19840 };
19841
19842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
19843 {
19844 if (!wxPyCheckForApp()) SWIG_fail;
19845 PyThreadState* __tstate = wxPyBeginAllowThreads();
19846 result = (wxColourDatabase *)new wxColourDatabase();
19847
19848 wxPyEndAllowThreads(__tstate);
19849 if (PyErr_Occurred()) SWIG_fail;
19850 }
19851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
19852 return resultobj;
19853 fail:
19854 return NULL;
19855 }
19856
19857
19858 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19859 PyObject *resultobj;
19860 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19861 PyObject * obj0 = 0 ;
19862 char *kwnames[] = {
19863 (char *) "self", NULL
19864 };
19865
19866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
19867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19868 if (SWIG_arg_fail(1)) SWIG_fail;
19869 {
19870 PyThreadState* __tstate = wxPyBeginAllowThreads();
19871 delete arg1;
19872
19873 wxPyEndAllowThreads(__tstate);
19874 if (PyErr_Occurred()) SWIG_fail;
19875 }
19876 Py_INCREF(Py_None); resultobj = Py_None;
19877 return resultobj;
19878 fail:
19879 return NULL;
19880 }
19881
19882
19883 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
19884 PyObject *resultobj;
19885 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19886 wxString *arg2 = 0 ;
19887 wxColour result;
19888 bool temp2 = false ;
19889 PyObject * obj0 = 0 ;
19890 PyObject * obj1 = 0 ;
19891 char *kwnames[] = {
19892 (char *) "self",(char *) "name", NULL
19893 };
19894
19895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
19896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19897 if (SWIG_arg_fail(1)) SWIG_fail;
19898 {
19899 arg2 = wxString_in_helper(obj1);
19900 if (arg2 == NULL) SWIG_fail;
19901 temp2 = true;
19902 }
19903 {
19904 PyThreadState* __tstate = wxPyBeginAllowThreads();
19905 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
19906
19907 wxPyEndAllowThreads(__tstate);
19908 if (PyErr_Occurred()) SWIG_fail;
19909 }
19910 {
19911 wxColour * resultptr;
19912 resultptr = new wxColour((wxColour &)(result));
19913 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19914 }
19915 {
19916 if (temp2)
19917 delete arg2;
19918 }
19919 return resultobj;
19920 fail:
19921 {
19922 if (temp2)
19923 delete arg2;
19924 }
19925 return NULL;
19926 }
19927
19928
19929 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
19930 PyObject *resultobj;
19931 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19932 wxColour *arg2 = 0 ;
19933 wxString result;
19934 wxColour temp2 ;
19935 PyObject * obj0 = 0 ;
19936 PyObject * obj1 = 0 ;
19937 char *kwnames[] = {
19938 (char *) "self",(char *) "colour", NULL
19939 };
19940
19941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
19942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19943 if (SWIG_arg_fail(1)) SWIG_fail;
19944 {
19945 arg2 = &temp2;
19946 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19947 }
19948 {
19949 PyThreadState* __tstate = wxPyBeginAllowThreads();
19950 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
19951
19952 wxPyEndAllowThreads(__tstate);
19953 if (PyErr_Occurred()) SWIG_fail;
19954 }
19955 {
19956 #if wxUSE_UNICODE
19957 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19958 #else
19959 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19960 #endif
19961 }
19962 return resultobj;
19963 fail:
19964 return NULL;
19965 }
19966
19967
19968 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
19969 PyObject *resultobj;
19970 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19971 wxString *arg2 = 0 ;
19972 wxColour *arg3 = 0 ;
19973 bool temp2 = false ;
19974 wxColour temp3 ;
19975 PyObject * obj0 = 0 ;
19976 PyObject * obj1 = 0 ;
19977 PyObject * obj2 = 0 ;
19978 char *kwnames[] = {
19979 (char *) "self",(char *) "name",(char *) "colour", NULL
19980 };
19981
19982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
19983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19984 if (SWIG_arg_fail(1)) SWIG_fail;
19985 {
19986 arg2 = wxString_in_helper(obj1);
19987 if (arg2 == NULL) SWIG_fail;
19988 temp2 = true;
19989 }
19990 {
19991 arg3 = &temp3;
19992 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19993 }
19994 {
19995 PyThreadState* __tstate = wxPyBeginAllowThreads();
19996 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
19997
19998 wxPyEndAllowThreads(__tstate);
19999 if (PyErr_Occurred()) SWIG_fail;
20000 }
20001 Py_INCREF(Py_None); resultobj = Py_None;
20002 {
20003 if (temp2)
20004 delete arg2;
20005 }
20006 return resultobj;
20007 fail:
20008 {
20009 if (temp2)
20010 delete arg2;
20011 }
20012 return NULL;
20013 }
20014
20015
20016 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
20017 PyObject *resultobj;
20018 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20019 wxString *arg2 = 0 ;
20020 int arg3 ;
20021 int arg4 ;
20022 int arg5 ;
20023 bool temp2 = false ;
20024 PyObject * obj0 = 0 ;
20025 PyObject * obj1 = 0 ;
20026 PyObject * obj2 = 0 ;
20027 PyObject * obj3 = 0 ;
20028 PyObject * obj4 = 0 ;
20029 char *kwnames[] = {
20030 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
20031 };
20032
20033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20035 if (SWIG_arg_fail(1)) SWIG_fail;
20036 {
20037 arg2 = wxString_in_helper(obj1);
20038 if (arg2 == NULL) SWIG_fail;
20039 temp2 = true;
20040 }
20041 {
20042 arg3 = (int)(SWIG_As_int(obj2));
20043 if (SWIG_arg_fail(3)) SWIG_fail;
20044 }
20045 {
20046 arg4 = (int)(SWIG_As_int(obj3));
20047 if (SWIG_arg_fail(4)) SWIG_fail;
20048 }
20049 {
20050 arg5 = (int)(SWIG_As_int(obj4));
20051 if (SWIG_arg_fail(5)) SWIG_fail;
20052 }
20053 {
20054 PyThreadState* __tstate = wxPyBeginAllowThreads();
20055 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
20056
20057 wxPyEndAllowThreads(__tstate);
20058 if (PyErr_Occurred()) SWIG_fail;
20059 }
20060 Py_INCREF(Py_None); resultobj = Py_None;
20061 {
20062 if (temp2)
20063 delete arg2;
20064 }
20065 return resultobj;
20066 fail:
20067 {
20068 if (temp2)
20069 delete arg2;
20070 }
20071 return NULL;
20072 }
20073
20074
20075 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
20076 PyObject *obj;
20077 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20078 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
20079 Py_INCREF(obj);
20080 return Py_BuildValue((char *)"");
20081 }
20082 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
20083 PyObject *resultobj;
20084 wxFontList *arg1 = (wxFontList *) 0 ;
20085 wxFont *arg2 = (wxFont *) 0 ;
20086 PyObject * obj0 = 0 ;
20087 PyObject * obj1 = 0 ;
20088 char *kwnames[] = {
20089 (char *) "self",(char *) "font", NULL
20090 };
20091
20092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
20093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20094 if (SWIG_arg_fail(1)) SWIG_fail;
20095 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20096 if (SWIG_arg_fail(2)) SWIG_fail;
20097 {
20098 PyThreadState* __tstate = wxPyBeginAllowThreads();
20099 (arg1)->AddFont(arg2);
20100
20101 wxPyEndAllowThreads(__tstate);
20102 if (PyErr_Occurred()) SWIG_fail;
20103 }
20104 Py_INCREF(Py_None); resultobj = Py_None;
20105 return resultobj;
20106 fail:
20107 return NULL;
20108 }
20109
20110
20111 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
20112 PyObject *resultobj;
20113 wxFontList *arg1 = (wxFontList *) 0 ;
20114 int arg2 ;
20115 int arg3 ;
20116 int arg4 ;
20117 int arg5 ;
20118 bool arg6 = (bool) false ;
20119 wxString const &arg7_defvalue = wxPyEmptyString ;
20120 wxString *arg7 = (wxString *) &arg7_defvalue ;
20121 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
20122 wxFont *result;
20123 bool temp7 = false ;
20124 PyObject * obj0 = 0 ;
20125 PyObject * obj1 = 0 ;
20126 PyObject * obj2 = 0 ;
20127 PyObject * obj3 = 0 ;
20128 PyObject * obj4 = 0 ;
20129 PyObject * obj5 = 0 ;
20130 PyObject * obj6 = 0 ;
20131 PyObject * obj7 = 0 ;
20132 char *kwnames[] = {
20133 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
20134 };
20135
20136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20138 if (SWIG_arg_fail(1)) SWIG_fail;
20139 {
20140 arg2 = (int)(SWIG_As_int(obj1));
20141 if (SWIG_arg_fail(2)) SWIG_fail;
20142 }
20143 {
20144 arg3 = (int)(SWIG_As_int(obj2));
20145 if (SWIG_arg_fail(3)) SWIG_fail;
20146 }
20147 {
20148 arg4 = (int)(SWIG_As_int(obj3));
20149 if (SWIG_arg_fail(4)) SWIG_fail;
20150 }
20151 {
20152 arg5 = (int)(SWIG_As_int(obj4));
20153 if (SWIG_arg_fail(5)) SWIG_fail;
20154 }
20155 if (obj5) {
20156 {
20157 arg6 = (bool)(SWIG_As_bool(obj5));
20158 if (SWIG_arg_fail(6)) SWIG_fail;
20159 }
20160 }
20161 if (obj6) {
20162 {
20163 arg7 = wxString_in_helper(obj6);
20164 if (arg7 == NULL) SWIG_fail;
20165 temp7 = true;
20166 }
20167 }
20168 if (obj7) {
20169 {
20170 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
20171 if (SWIG_arg_fail(8)) SWIG_fail;
20172 }
20173 }
20174 {
20175 PyThreadState* __tstate = wxPyBeginAllowThreads();
20176 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
20177
20178 wxPyEndAllowThreads(__tstate);
20179 if (PyErr_Occurred()) SWIG_fail;
20180 }
20181 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
20182 {
20183 if (temp7)
20184 delete arg7;
20185 }
20186 return resultobj;
20187 fail:
20188 {
20189 if (temp7)
20190 delete arg7;
20191 }
20192 return NULL;
20193 }
20194
20195
20196 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
20197 PyObject *resultobj;
20198 wxFontList *arg1 = (wxFontList *) 0 ;
20199 wxFont *arg2 = (wxFont *) 0 ;
20200 PyObject * obj0 = 0 ;
20201 PyObject * obj1 = 0 ;
20202 char *kwnames[] = {
20203 (char *) "self",(char *) "font", NULL
20204 };
20205
20206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
20207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20208 if (SWIG_arg_fail(1)) SWIG_fail;
20209 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20210 if (SWIG_arg_fail(2)) SWIG_fail;
20211 {
20212 PyThreadState* __tstate = wxPyBeginAllowThreads();
20213 (arg1)->RemoveFont(arg2);
20214
20215 wxPyEndAllowThreads(__tstate);
20216 if (PyErr_Occurred()) SWIG_fail;
20217 }
20218 Py_INCREF(Py_None); resultobj = Py_None;
20219 return resultobj;
20220 fail:
20221 return NULL;
20222 }
20223
20224
20225 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20226 PyObject *resultobj;
20227 wxFontList *arg1 = (wxFontList *) 0 ;
20228 int result;
20229 PyObject * obj0 = 0 ;
20230 char *kwnames[] = {
20231 (char *) "self", NULL
20232 };
20233
20234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
20235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20236 if (SWIG_arg_fail(1)) SWIG_fail;
20237 {
20238 PyThreadState* __tstate = wxPyBeginAllowThreads();
20239 result = (int)(arg1)->GetCount();
20240
20241 wxPyEndAllowThreads(__tstate);
20242 if (PyErr_Occurred()) SWIG_fail;
20243 }
20244 {
20245 resultobj = SWIG_From_int((int)(result));
20246 }
20247 return resultobj;
20248 fail:
20249 return NULL;
20250 }
20251
20252
20253 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
20254 PyObject *obj;
20255 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20256 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
20257 Py_INCREF(obj);
20258 return Py_BuildValue((char *)"");
20259 }
20260 static int _wrap_TheFontList_set(PyObject *) {
20261 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
20262 return 1;
20263 }
20264
20265
20266 static PyObject *_wrap_TheFontList_get(void) {
20267 PyObject *pyobj;
20268
20269 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
20270 return pyobj;
20271 }
20272
20273
20274 static int _wrap_ThePenList_set(PyObject *) {
20275 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
20276 return 1;
20277 }
20278
20279
20280 static PyObject *_wrap_ThePenList_get(void) {
20281 PyObject *pyobj;
20282
20283 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
20284 return pyobj;
20285 }
20286
20287
20288 static int _wrap_TheBrushList_set(PyObject *) {
20289 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
20290 return 1;
20291 }
20292
20293
20294 static PyObject *_wrap_TheBrushList_get(void) {
20295 PyObject *pyobj;
20296
20297 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
20298 return pyobj;
20299 }
20300
20301
20302 static int _wrap_TheColourDatabase_set(PyObject *) {
20303 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
20304 return 1;
20305 }
20306
20307
20308 static PyObject *_wrap_TheColourDatabase_get(void) {
20309 PyObject *pyobj;
20310
20311 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
20312 return pyobj;
20313 }
20314
20315
20316 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
20317 PyObject *resultobj;
20318 wxEffects *result;
20319 char *kwnames[] = {
20320 NULL
20321 };
20322
20323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
20324 {
20325 PyThreadState* __tstate = wxPyBeginAllowThreads();
20326 result = (wxEffects *)new wxEffects();
20327
20328 wxPyEndAllowThreads(__tstate);
20329 if (PyErr_Occurred()) SWIG_fail;
20330 }
20331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
20332 return resultobj;
20333 fail:
20334 return NULL;
20335 }
20336
20337
20338 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20339 PyObject *resultobj;
20340 wxEffects *arg1 = (wxEffects *) 0 ;
20341 wxColour result;
20342 PyObject * obj0 = 0 ;
20343 char *kwnames[] = {
20344 (char *) "self", NULL
20345 };
20346
20347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
20348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20349 if (SWIG_arg_fail(1)) SWIG_fail;
20350 {
20351 PyThreadState* __tstate = wxPyBeginAllowThreads();
20352 result = ((wxEffects const *)arg1)->GetHighlightColour();
20353
20354 wxPyEndAllowThreads(__tstate);
20355 if (PyErr_Occurred()) SWIG_fail;
20356 }
20357 {
20358 wxColour * resultptr;
20359 resultptr = new wxColour((wxColour &)(result));
20360 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20361 }
20362 return resultobj;
20363 fail:
20364 return NULL;
20365 }
20366
20367
20368 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20369 PyObject *resultobj;
20370 wxEffects *arg1 = (wxEffects *) 0 ;
20371 wxColour result;
20372 PyObject * obj0 = 0 ;
20373 char *kwnames[] = {
20374 (char *) "self", NULL
20375 };
20376
20377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
20378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20379 if (SWIG_arg_fail(1)) SWIG_fail;
20380 {
20381 PyThreadState* __tstate = wxPyBeginAllowThreads();
20382 result = ((wxEffects const *)arg1)->GetLightShadow();
20383
20384 wxPyEndAllowThreads(__tstate);
20385 if (PyErr_Occurred()) SWIG_fail;
20386 }
20387 {
20388 wxColour * resultptr;
20389 resultptr = new wxColour((wxColour &)(result));
20390 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20391 }
20392 return resultobj;
20393 fail:
20394 return NULL;
20395 }
20396
20397
20398 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20399 PyObject *resultobj;
20400 wxEffects *arg1 = (wxEffects *) 0 ;
20401 wxColour result;
20402 PyObject * obj0 = 0 ;
20403 char *kwnames[] = {
20404 (char *) "self", NULL
20405 };
20406
20407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
20408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20409 if (SWIG_arg_fail(1)) SWIG_fail;
20410 {
20411 PyThreadState* __tstate = wxPyBeginAllowThreads();
20412 result = ((wxEffects const *)arg1)->GetFaceColour();
20413
20414 wxPyEndAllowThreads(__tstate);
20415 if (PyErr_Occurred()) SWIG_fail;
20416 }
20417 {
20418 wxColour * resultptr;
20419 resultptr = new wxColour((wxColour &)(result));
20420 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20421 }
20422 return resultobj;
20423 fail:
20424 return NULL;
20425 }
20426
20427
20428 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20429 PyObject *resultobj;
20430 wxEffects *arg1 = (wxEffects *) 0 ;
20431 wxColour result;
20432 PyObject * obj0 = 0 ;
20433 char *kwnames[] = {
20434 (char *) "self", NULL
20435 };
20436
20437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
20442 result = ((wxEffects const *)arg1)->GetMediumShadow();
20443
20444 wxPyEndAllowThreads(__tstate);
20445 if (PyErr_Occurred()) SWIG_fail;
20446 }
20447 {
20448 wxColour * resultptr;
20449 resultptr = new wxColour((wxColour &)(result));
20450 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20451 }
20452 return resultobj;
20453 fail:
20454 return NULL;
20455 }
20456
20457
20458 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20459 PyObject *resultobj;
20460 wxEffects *arg1 = (wxEffects *) 0 ;
20461 wxColour result;
20462 PyObject * obj0 = 0 ;
20463 char *kwnames[] = {
20464 (char *) "self", NULL
20465 };
20466
20467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
20468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20469 if (SWIG_arg_fail(1)) SWIG_fail;
20470 {
20471 PyThreadState* __tstate = wxPyBeginAllowThreads();
20472 result = ((wxEffects const *)arg1)->GetDarkShadow();
20473
20474 wxPyEndAllowThreads(__tstate);
20475 if (PyErr_Occurred()) SWIG_fail;
20476 }
20477 {
20478 wxColour * resultptr;
20479 resultptr = new wxColour((wxColour &)(result));
20480 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20481 }
20482 return resultobj;
20483 fail:
20484 return NULL;
20485 }
20486
20487
20488 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20489 PyObject *resultobj;
20490 wxEffects *arg1 = (wxEffects *) 0 ;
20491 wxColour *arg2 = 0 ;
20492 wxColour temp2 ;
20493 PyObject * obj0 = 0 ;
20494 PyObject * obj1 = 0 ;
20495 char *kwnames[] = {
20496 (char *) "self",(char *) "c", NULL
20497 };
20498
20499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
20500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20501 if (SWIG_arg_fail(1)) SWIG_fail;
20502 {
20503 arg2 = &temp2;
20504 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20505 }
20506 {
20507 PyThreadState* __tstate = wxPyBeginAllowThreads();
20508 (arg1)->SetHighlightColour((wxColour const &)*arg2);
20509
20510 wxPyEndAllowThreads(__tstate);
20511 if (PyErr_Occurred()) SWIG_fail;
20512 }
20513 Py_INCREF(Py_None); resultobj = Py_None;
20514 return resultobj;
20515 fail:
20516 return NULL;
20517 }
20518
20519
20520 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20521 PyObject *resultobj;
20522 wxEffects *arg1 = (wxEffects *) 0 ;
20523 wxColour *arg2 = 0 ;
20524 wxColour temp2 ;
20525 PyObject * obj0 = 0 ;
20526 PyObject * obj1 = 0 ;
20527 char *kwnames[] = {
20528 (char *) "self",(char *) "c", NULL
20529 };
20530
20531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
20532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20533 if (SWIG_arg_fail(1)) SWIG_fail;
20534 {
20535 arg2 = &temp2;
20536 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20537 }
20538 {
20539 PyThreadState* __tstate = wxPyBeginAllowThreads();
20540 (arg1)->SetLightShadow((wxColour const &)*arg2);
20541
20542 wxPyEndAllowThreads(__tstate);
20543 if (PyErr_Occurred()) SWIG_fail;
20544 }
20545 Py_INCREF(Py_None); resultobj = Py_None;
20546 return resultobj;
20547 fail:
20548 return NULL;
20549 }
20550
20551
20552 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20553 PyObject *resultobj;
20554 wxEffects *arg1 = (wxEffects *) 0 ;
20555 wxColour *arg2 = 0 ;
20556 wxColour temp2 ;
20557 PyObject * obj0 = 0 ;
20558 PyObject * obj1 = 0 ;
20559 char *kwnames[] = {
20560 (char *) "self",(char *) "c", NULL
20561 };
20562
20563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
20564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20565 if (SWIG_arg_fail(1)) SWIG_fail;
20566 {
20567 arg2 = &temp2;
20568 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20569 }
20570 {
20571 PyThreadState* __tstate = wxPyBeginAllowThreads();
20572 (arg1)->SetFaceColour((wxColour const &)*arg2);
20573
20574 wxPyEndAllowThreads(__tstate);
20575 if (PyErr_Occurred()) SWIG_fail;
20576 }
20577 Py_INCREF(Py_None); resultobj = Py_None;
20578 return resultobj;
20579 fail:
20580 return NULL;
20581 }
20582
20583
20584 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20585 PyObject *resultobj;
20586 wxEffects *arg1 = (wxEffects *) 0 ;
20587 wxColour *arg2 = 0 ;
20588 wxColour temp2 ;
20589 PyObject * obj0 = 0 ;
20590 PyObject * obj1 = 0 ;
20591 char *kwnames[] = {
20592 (char *) "self",(char *) "c", NULL
20593 };
20594
20595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
20596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20597 if (SWIG_arg_fail(1)) SWIG_fail;
20598 {
20599 arg2 = &temp2;
20600 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20601 }
20602 {
20603 PyThreadState* __tstate = wxPyBeginAllowThreads();
20604 (arg1)->SetMediumShadow((wxColour const &)*arg2);
20605
20606 wxPyEndAllowThreads(__tstate);
20607 if (PyErr_Occurred()) SWIG_fail;
20608 }
20609 Py_INCREF(Py_None); resultobj = Py_None;
20610 return resultobj;
20611 fail:
20612 return NULL;
20613 }
20614
20615
20616 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20617 PyObject *resultobj;
20618 wxEffects *arg1 = (wxEffects *) 0 ;
20619 wxColour *arg2 = 0 ;
20620 wxColour temp2 ;
20621 PyObject * obj0 = 0 ;
20622 PyObject * obj1 = 0 ;
20623 char *kwnames[] = {
20624 (char *) "self",(char *) "c", NULL
20625 };
20626
20627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
20628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20629 if (SWIG_arg_fail(1)) SWIG_fail;
20630 {
20631 arg2 = &temp2;
20632 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20633 }
20634 {
20635 PyThreadState* __tstate = wxPyBeginAllowThreads();
20636 (arg1)->SetDarkShadow((wxColour const &)*arg2);
20637
20638 wxPyEndAllowThreads(__tstate);
20639 if (PyErr_Occurred()) SWIG_fail;
20640 }
20641 Py_INCREF(Py_None); resultobj = Py_None;
20642 return resultobj;
20643 fail:
20644 return NULL;
20645 }
20646
20647
20648 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20649 PyObject *resultobj;
20650 wxEffects *arg1 = (wxEffects *) 0 ;
20651 wxColour *arg2 = 0 ;
20652 wxColour *arg3 = 0 ;
20653 wxColour *arg4 = 0 ;
20654 wxColour *arg5 = 0 ;
20655 wxColour *arg6 = 0 ;
20656 wxColour temp2 ;
20657 wxColour temp3 ;
20658 wxColour temp4 ;
20659 wxColour temp5 ;
20660 wxColour temp6 ;
20661 PyObject * obj0 = 0 ;
20662 PyObject * obj1 = 0 ;
20663 PyObject * obj2 = 0 ;
20664 PyObject * obj3 = 0 ;
20665 PyObject * obj4 = 0 ;
20666 PyObject * obj5 = 0 ;
20667 char *kwnames[] = {
20668 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
20669 };
20670
20671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
20672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20673 if (SWIG_arg_fail(1)) SWIG_fail;
20674 {
20675 arg2 = &temp2;
20676 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20677 }
20678 {
20679 arg3 = &temp3;
20680 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20681 }
20682 {
20683 arg4 = &temp4;
20684 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
20685 }
20686 {
20687 arg5 = &temp5;
20688 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
20689 }
20690 {
20691 arg6 = &temp6;
20692 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
20693 }
20694 {
20695 PyThreadState* __tstate = wxPyBeginAllowThreads();
20696 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
20697
20698 wxPyEndAllowThreads(__tstate);
20699 if (PyErr_Occurred()) SWIG_fail;
20700 }
20701 Py_INCREF(Py_None); resultobj = Py_None;
20702 return resultobj;
20703 fail:
20704 return NULL;
20705 }
20706
20707
20708 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
20709 PyObject *resultobj;
20710 wxEffects *arg1 = (wxEffects *) 0 ;
20711 wxDC *arg2 = 0 ;
20712 wxRect *arg3 = 0 ;
20713 int arg4 = (int) 1 ;
20714 wxRect temp3 ;
20715 PyObject * obj0 = 0 ;
20716 PyObject * obj1 = 0 ;
20717 PyObject * obj2 = 0 ;
20718 PyObject * obj3 = 0 ;
20719 char *kwnames[] = {
20720 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
20721 };
20722
20723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20725 if (SWIG_arg_fail(1)) SWIG_fail;
20726 {
20727 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20728 if (SWIG_arg_fail(2)) SWIG_fail;
20729 if (arg2 == NULL) {
20730 SWIG_null_ref("wxDC");
20731 }
20732 if (SWIG_arg_fail(2)) SWIG_fail;
20733 }
20734 {
20735 arg3 = &temp3;
20736 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
20737 }
20738 if (obj3) {
20739 {
20740 arg4 = (int)(SWIG_As_int(obj3));
20741 if (SWIG_arg_fail(4)) SWIG_fail;
20742 }
20743 }
20744 {
20745 PyThreadState* __tstate = wxPyBeginAllowThreads();
20746 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
20747
20748 wxPyEndAllowThreads(__tstate);
20749 if (PyErr_Occurred()) SWIG_fail;
20750 }
20751 Py_INCREF(Py_None); resultobj = Py_None;
20752 return resultobj;
20753 fail:
20754 return NULL;
20755 }
20756
20757
20758 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
20759 PyObject *resultobj;
20760 wxEffects *arg1 = (wxEffects *) 0 ;
20761 wxRect *arg2 = 0 ;
20762 wxDC *arg3 = 0 ;
20763 wxBitmap *arg4 = 0 ;
20764 bool result;
20765 wxRect temp2 ;
20766 PyObject * obj0 = 0 ;
20767 PyObject * obj1 = 0 ;
20768 PyObject * obj2 = 0 ;
20769 PyObject * obj3 = 0 ;
20770 char *kwnames[] = {
20771 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
20772 };
20773
20774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20776 if (SWIG_arg_fail(1)) SWIG_fail;
20777 {
20778 arg2 = &temp2;
20779 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20780 }
20781 {
20782 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20783 if (SWIG_arg_fail(3)) SWIG_fail;
20784 if (arg3 == NULL) {
20785 SWIG_null_ref("wxDC");
20786 }
20787 if (SWIG_arg_fail(3)) SWIG_fail;
20788 }
20789 {
20790 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
20791 if (SWIG_arg_fail(4)) SWIG_fail;
20792 if (arg4 == NULL) {
20793 SWIG_null_ref("wxBitmap");
20794 }
20795 if (SWIG_arg_fail(4)) SWIG_fail;
20796 }
20797 {
20798 PyThreadState* __tstate = wxPyBeginAllowThreads();
20799 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
20800
20801 wxPyEndAllowThreads(__tstate);
20802 if (PyErr_Occurred()) SWIG_fail;
20803 }
20804 {
20805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20806 }
20807 return resultobj;
20808 fail:
20809 return NULL;
20810 }
20811
20812
20813 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
20814 PyObject *obj;
20815 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20816 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
20817 Py_INCREF(obj);
20818 return Py_BuildValue((char *)"");
20819 }
20820 static PyObject *_wrap_new_SplitterRenderParams(PyObject *, PyObject *args, PyObject *kwargs) {
20821 PyObject *resultobj;
20822 int arg1 ;
20823 int arg2 ;
20824 bool arg3 ;
20825 wxSplitterRenderParams *result;
20826 PyObject * obj0 = 0 ;
20827 PyObject * obj1 = 0 ;
20828 PyObject * obj2 = 0 ;
20829 char *kwnames[] = {
20830 (char *) "widthSash_",(char *) "border_",(char *) "isSens_", NULL
20831 };
20832
20833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_SplitterRenderParams",kwnames,&obj0,&obj1,&obj2)) goto fail;
20834 {
20835 arg1 = (int)(SWIG_As_int(obj0));
20836 if (SWIG_arg_fail(1)) SWIG_fail;
20837 }
20838 {
20839 arg2 = (int)(SWIG_As_int(obj1));
20840 if (SWIG_arg_fail(2)) SWIG_fail;
20841 }
20842 {
20843 arg3 = (bool)(SWIG_As_bool(obj2));
20844 if (SWIG_arg_fail(3)) SWIG_fail;
20845 }
20846 {
20847 PyThreadState* __tstate = wxPyBeginAllowThreads();
20848 result = (wxSplitterRenderParams *)new wxSplitterRenderParams(arg1,arg2,arg3);
20849
20850 wxPyEndAllowThreads(__tstate);
20851 if (PyErr_Occurred()) SWIG_fail;
20852 }
20853 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplitterRenderParams, 1);
20854 return resultobj;
20855 fail:
20856 return NULL;
20857 }
20858
20859
20860 static PyObject *_wrap_delete_SplitterRenderParams(PyObject *, PyObject *args, PyObject *kwargs) {
20861 PyObject *resultobj;
20862 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
20863 PyObject * obj0 = 0 ;
20864 char *kwnames[] = {
20865 (char *) "self", NULL
20866 };
20867
20868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SplitterRenderParams",kwnames,&obj0)) goto fail;
20869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
20870 if (SWIG_arg_fail(1)) SWIG_fail;
20871 {
20872 PyThreadState* __tstate = wxPyBeginAllowThreads();
20873 delete arg1;
20874
20875 wxPyEndAllowThreads(__tstate);
20876 if (PyErr_Occurred()) SWIG_fail;
20877 }
20878 Py_INCREF(Py_None); resultobj = Py_None;
20879 return resultobj;
20880 fail:
20881 return NULL;
20882 }
20883
20884
20885 static PyObject *_wrap_SplitterRenderParams_widthSash_get(PyObject *, PyObject *args, PyObject *kwargs) {
20886 PyObject *resultobj;
20887 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
20888 int result;
20889 PyObject * obj0 = 0 ;
20890 char *kwnames[] = {
20891 (char *) "self", NULL
20892 };
20893
20894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterRenderParams_widthSash_get",kwnames,&obj0)) goto fail;
20895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
20896 if (SWIG_arg_fail(1)) SWIG_fail;
20897 result = (int)(int) ((arg1)->widthSash);
20898
20899 {
20900 resultobj = SWIG_From_int((int)(result));
20901 }
20902 return resultobj;
20903 fail:
20904 return NULL;
20905 }
20906
20907
20908 static PyObject *_wrap_SplitterRenderParams_border_get(PyObject *, PyObject *args, PyObject *kwargs) {
20909 PyObject *resultobj;
20910 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
20911 int result;
20912 PyObject * obj0 = 0 ;
20913 char *kwnames[] = {
20914 (char *) "self", NULL
20915 };
20916
20917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterRenderParams_border_get",kwnames,&obj0)) goto fail;
20918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
20919 if (SWIG_arg_fail(1)) SWIG_fail;
20920 result = (int)(int) ((arg1)->border);
20921
20922 {
20923 resultobj = SWIG_From_int((int)(result));
20924 }
20925 return resultobj;
20926 fail:
20927 return NULL;
20928 }
20929
20930
20931 static PyObject *_wrap_SplitterRenderParams_isHotSensitive_get(PyObject *, PyObject *args, PyObject *kwargs) {
20932 PyObject *resultobj;
20933 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
20934 bool result;
20935 PyObject * obj0 = 0 ;
20936 char *kwnames[] = {
20937 (char *) "self", NULL
20938 };
20939
20940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterRenderParams_isHotSensitive_get",kwnames,&obj0)) goto fail;
20941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
20942 if (SWIG_arg_fail(1)) SWIG_fail;
20943 result = (bool)(bool) ((arg1)->isHotSensitive);
20944
20945 {
20946 resultobj = SWIG_From_bool((bool)(result));
20947 }
20948 return resultobj;
20949 fail:
20950 return NULL;
20951 }
20952
20953
20954 static PyObject * SplitterRenderParams_swigregister(PyObject *, PyObject *args) {
20955 PyObject *obj;
20956 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20957 SWIG_TypeClientData(SWIGTYPE_p_wxSplitterRenderParams, obj);
20958 Py_INCREF(obj);
20959 return Py_BuildValue((char *)"");
20960 }
20961 static PyObject *_wrap_new_RendererVersion(PyObject *, PyObject *args, PyObject *kwargs) {
20962 PyObject *resultobj;
20963 int arg1 ;
20964 int arg2 ;
20965 wxRendererVersion *result;
20966 PyObject * obj0 = 0 ;
20967 PyObject * obj1 = 0 ;
20968 char *kwnames[] = {
20969 (char *) "version_",(char *) "age_", NULL
20970 };
20971
20972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RendererVersion",kwnames,&obj0,&obj1)) goto fail;
20973 {
20974 arg1 = (int)(SWIG_As_int(obj0));
20975 if (SWIG_arg_fail(1)) SWIG_fail;
20976 }
20977 {
20978 arg2 = (int)(SWIG_As_int(obj1));
20979 if (SWIG_arg_fail(2)) SWIG_fail;
20980 }
20981 {
20982 PyThreadState* __tstate = wxPyBeginAllowThreads();
20983 result = (wxRendererVersion *)new wxRendererVersion(arg1,arg2);
20984
20985 wxPyEndAllowThreads(__tstate);
20986 if (PyErr_Occurred()) SWIG_fail;
20987 }
20988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererVersion, 1);
20989 return resultobj;
20990 fail:
20991 return NULL;
20992 }
20993
20994
20995 static PyObject *_wrap_delete_RendererVersion(PyObject *, PyObject *args, PyObject *kwargs) {
20996 PyObject *resultobj;
20997 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
20998 PyObject * obj0 = 0 ;
20999 char *kwnames[] = {
21000 (char *) "self", NULL
21001 };
21002
21003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RendererVersion",kwnames,&obj0)) goto fail;
21004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
21005 if (SWIG_arg_fail(1)) SWIG_fail;
21006 {
21007 PyThreadState* __tstate = wxPyBeginAllowThreads();
21008 delete arg1;
21009
21010 wxPyEndAllowThreads(__tstate);
21011 if (PyErr_Occurred()) SWIG_fail;
21012 }
21013 Py_INCREF(Py_None); resultobj = Py_None;
21014 return resultobj;
21015 fail:
21016 return NULL;
21017 }
21018
21019
21020 static PyObject *_wrap_RendererVersion_IsCompatible(PyObject *, PyObject *args, PyObject *kwargs) {
21021 PyObject *resultobj;
21022 wxRendererVersion *arg1 = 0 ;
21023 bool result;
21024 PyObject * obj0 = 0 ;
21025 char *kwnames[] = {
21026 (char *) "ver", NULL
21027 };
21028
21029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_IsCompatible",kwnames,&obj0)) goto fail;
21030 {
21031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
21032 if (SWIG_arg_fail(1)) SWIG_fail;
21033 if (arg1 == NULL) {
21034 SWIG_null_ref("wxRendererVersion");
21035 }
21036 if (SWIG_arg_fail(1)) SWIG_fail;
21037 }
21038 {
21039 PyThreadState* __tstate = wxPyBeginAllowThreads();
21040 result = (bool)wxRendererVersion::IsCompatible((wxRendererVersion const &)*arg1);
21041
21042 wxPyEndAllowThreads(__tstate);
21043 if (PyErr_Occurred()) SWIG_fail;
21044 }
21045 {
21046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21047 }
21048 return resultobj;
21049 fail:
21050 return NULL;
21051 }
21052
21053
21054 static PyObject *_wrap_RendererVersion_version_get(PyObject *, PyObject *args, PyObject *kwargs) {
21055 PyObject *resultobj;
21056 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
21057 int result;
21058 PyObject * obj0 = 0 ;
21059 char *kwnames[] = {
21060 (char *) "self", NULL
21061 };
21062
21063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_version_get",kwnames,&obj0)) goto fail;
21064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
21065 if (SWIG_arg_fail(1)) SWIG_fail;
21066 result = (int)(int) ((arg1)->version);
21067
21068 {
21069 resultobj = SWIG_From_int((int)(result));
21070 }
21071 return resultobj;
21072 fail:
21073 return NULL;
21074 }
21075
21076
21077 static PyObject *_wrap_RendererVersion_age_get(PyObject *, PyObject *args, PyObject *kwargs) {
21078 PyObject *resultobj;
21079 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
21080 int result;
21081 PyObject * obj0 = 0 ;
21082 char *kwnames[] = {
21083 (char *) "self", NULL
21084 };
21085
21086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_age_get",kwnames,&obj0)) goto fail;
21087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
21088 if (SWIG_arg_fail(1)) SWIG_fail;
21089 result = (int)(int) ((arg1)->age);
21090
21091 {
21092 resultobj = SWIG_From_int((int)(result));
21093 }
21094 return resultobj;
21095 fail:
21096 return NULL;
21097 }
21098
21099
21100 static PyObject * RendererVersion_swigregister(PyObject *, PyObject *args) {
21101 PyObject *obj;
21102 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21103 SWIG_TypeClientData(SWIGTYPE_p_wxRendererVersion, obj);
21104 Py_INCREF(obj);
21105 return Py_BuildValue((char *)"");
21106 }
21107 static PyObject *_wrap_RendererNative_DrawHeaderButton(PyObject *, PyObject *args, PyObject *kwargs) {
21108 PyObject *resultobj;
21109 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21110 wxWindow *arg2 = (wxWindow *) 0 ;
21111 wxDC *arg3 = 0 ;
21112 wxRect *arg4 = 0 ;
21113 int arg5 = (int) 0 ;
21114 wxRect temp4 ;
21115 PyObject * obj0 = 0 ;
21116 PyObject * obj1 = 0 ;
21117 PyObject * obj2 = 0 ;
21118 PyObject * obj3 = 0 ;
21119 PyObject * obj4 = 0 ;
21120 char *kwnames[] = {
21121 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21122 };
21123
21124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawHeaderButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21126 if (SWIG_arg_fail(1)) SWIG_fail;
21127 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21128 if (SWIG_arg_fail(2)) SWIG_fail;
21129 {
21130 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21131 if (SWIG_arg_fail(3)) SWIG_fail;
21132 if (arg3 == NULL) {
21133 SWIG_null_ref("wxDC");
21134 }
21135 if (SWIG_arg_fail(3)) SWIG_fail;
21136 }
21137 {
21138 arg4 = &temp4;
21139 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21140 }
21141 if (obj4) {
21142 {
21143 arg5 = (int)(SWIG_As_int(obj4));
21144 if (SWIG_arg_fail(5)) SWIG_fail;
21145 }
21146 }
21147 {
21148 PyThreadState* __tstate = wxPyBeginAllowThreads();
21149 (arg1)->DrawHeaderButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
21150
21151 wxPyEndAllowThreads(__tstate);
21152 if (PyErr_Occurred()) SWIG_fail;
21153 }
21154 Py_INCREF(Py_None); resultobj = Py_None;
21155 return resultobj;
21156 fail:
21157 return NULL;
21158 }
21159
21160
21161 static PyObject *_wrap_RendererNative_DrawTreeItemButton(PyObject *, PyObject *args, PyObject *kwargs) {
21162 PyObject *resultobj;
21163 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21164 wxWindow *arg2 = (wxWindow *) 0 ;
21165 wxDC *arg3 = 0 ;
21166 wxRect *arg4 = 0 ;
21167 int arg5 = (int) 0 ;
21168 wxRect temp4 ;
21169 PyObject * obj0 = 0 ;
21170 PyObject * obj1 = 0 ;
21171 PyObject * obj2 = 0 ;
21172 PyObject * obj3 = 0 ;
21173 PyObject * obj4 = 0 ;
21174 char *kwnames[] = {
21175 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21176 };
21177
21178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawTreeItemButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21180 if (SWIG_arg_fail(1)) SWIG_fail;
21181 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21182 if (SWIG_arg_fail(2)) SWIG_fail;
21183 {
21184 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21185 if (SWIG_arg_fail(3)) SWIG_fail;
21186 if (arg3 == NULL) {
21187 SWIG_null_ref("wxDC");
21188 }
21189 if (SWIG_arg_fail(3)) SWIG_fail;
21190 }
21191 {
21192 arg4 = &temp4;
21193 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21194 }
21195 if (obj4) {
21196 {
21197 arg5 = (int)(SWIG_As_int(obj4));
21198 if (SWIG_arg_fail(5)) SWIG_fail;
21199 }
21200 }
21201 {
21202 PyThreadState* __tstate = wxPyBeginAllowThreads();
21203 (arg1)->DrawTreeItemButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
21204
21205 wxPyEndAllowThreads(__tstate);
21206 if (PyErr_Occurred()) SWIG_fail;
21207 }
21208 Py_INCREF(Py_None); resultobj = Py_None;
21209 return resultobj;
21210 fail:
21211 return NULL;
21212 }
21213
21214
21215 static PyObject *_wrap_RendererNative_DrawSplitterBorder(PyObject *, PyObject *args, PyObject *kwargs) {
21216 PyObject *resultobj;
21217 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21218 wxWindow *arg2 = (wxWindow *) 0 ;
21219 wxDC *arg3 = 0 ;
21220 wxRect *arg4 = 0 ;
21221 int arg5 = (int) 0 ;
21222 wxRect temp4 ;
21223 PyObject * obj0 = 0 ;
21224 PyObject * obj1 = 0 ;
21225 PyObject * obj2 = 0 ;
21226 PyObject * obj3 = 0 ;
21227 PyObject * obj4 = 0 ;
21228 char *kwnames[] = {
21229 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21230 };
21231
21232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawSplitterBorder",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21234 if (SWIG_arg_fail(1)) SWIG_fail;
21235 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21236 if (SWIG_arg_fail(2)) SWIG_fail;
21237 {
21238 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21239 if (SWIG_arg_fail(3)) SWIG_fail;
21240 if (arg3 == NULL) {
21241 SWIG_null_ref("wxDC");
21242 }
21243 if (SWIG_arg_fail(3)) SWIG_fail;
21244 }
21245 {
21246 arg4 = &temp4;
21247 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21248 }
21249 if (obj4) {
21250 {
21251 arg5 = (int)(SWIG_As_int(obj4));
21252 if (SWIG_arg_fail(5)) SWIG_fail;
21253 }
21254 }
21255 {
21256 PyThreadState* __tstate = wxPyBeginAllowThreads();
21257 (arg1)->DrawSplitterBorder(arg2,*arg3,(wxRect const &)*arg4,arg5);
21258
21259 wxPyEndAllowThreads(__tstate);
21260 if (PyErr_Occurred()) SWIG_fail;
21261 }
21262 Py_INCREF(Py_None); resultobj = Py_None;
21263 return resultobj;
21264 fail:
21265 return NULL;
21266 }
21267
21268
21269 static PyObject *_wrap_RendererNative_DrawSplitterSash(PyObject *, PyObject *args, PyObject *kwargs) {
21270 PyObject *resultobj;
21271 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21272 wxWindow *arg2 = (wxWindow *) 0 ;
21273 wxDC *arg3 = 0 ;
21274 wxSize *arg4 = 0 ;
21275 int arg5 ;
21276 wxOrientation arg6 ;
21277 int arg7 = (int) 0 ;
21278 wxSize temp4 ;
21279 PyObject * obj0 = 0 ;
21280 PyObject * obj1 = 0 ;
21281 PyObject * obj2 = 0 ;
21282 PyObject * obj3 = 0 ;
21283 PyObject * obj4 = 0 ;
21284 PyObject * obj5 = 0 ;
21285 PyObject * obj6 = 0 ;
21286 char *kwnames[] = {
21287 (char *) "self",(char *) "win",(char *) "dc",(char *) "size",(char *) "position",(char *) "orient",(char *) "flags", NULL
21288 };
21289
21290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:RendererNative_DrawSplitterSash",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
21291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21292 if (SWIG_arg_fail(1)) SWIG_fail;
21293 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21294 if (SWIG_arg_fail(2)) SWIG_fail;
21295 {
21296 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21297 if (SWIG_arg_fail(3)) SWIG_fail;
21298 if (arg3 == NULL) {
21299 SWIG_null_ref("wxDC");
21300 }
21301 if (SWIG_arg_fail(3)) SWIG_fail;
21302 }
21303 {
21304 arg4 = &temp4;
21305 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
21306 }
21307 {
21308 arg5 = (int)(SWIG_As_int(obj4));
21309 if (SWIG_arg_fail(5)) SWIG_fail;
21310 }
21311 {
21312 arg6 = (wxOrientation)(SWIG_As_int(obj5));
21313 if (SWIG_arg_fail(6)) SWIG_fail;
21314 }
21315 if (obj6) {
21316 {
21317 arg7 = (int)(SWIG_As_int(obj6));
21318 if (SWIG_arg_fail(7)) SWIG_fail;
21319 }
21320 }
21321 {
21322 PyThreadState* __tstate = wxPyBeginAllowThreads();
21323 (arg1)->DrawSplitterSash(arg2,*arg3,(wxSize const &)*arg4,arg5,(wxOrientation )arg6,arg7);
21324
21325 wxPyEndAllowThreads(__tstate);
21326 if (PyErr_Occurred()) SWIG_fail;
21327 }
21328 Py_INCREF(Py_None); resultobj = Py_None;
21329 return resultobj;
21330 fail:
21331 return NULL;
21332 }
21333
21334
21335 static PyObject *_wrap_RendererNative_DrawComboBoxDropButton(PyObject *, PyObject *args, PyObject *kwargs) {
21336 PyObject *resultobj;
21337 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21338 wxWindow *arg2 = (wxWindow *) 0 ;
21339 wxDC *arg3 = 0 ;
21340 wxRect *arg4 = 0 ;
21341 int arg5 = (int) 0 ;
21342 wxRect temp4 ;
21343 PyObject * obj0 = 0 ;
21344 PyObject * obj1 = 0 ;
21345 PyObject * obj2 = 0 ;
21346 PyObject * obj3 = 0 ;
21347 PyObject * obj4 = 0 ;
21348 char *kwnames[] = {
21349 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21350 };
21351
21352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawComboBoxDropButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21354 if (SWIG_arg_fail(1)) SWIG_fail;
21355 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21356 if (SWIG_arg_fail(2)) SWIG_fail;
21357 {
21358 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21359 if (SWIG_arg_fail(3)) SWIG_fail;
21360 if (arg3 == NULL) {
21361 SWIG_null_ref("wxDC");
21362 }
21363 if (SWIG_arg_fail(3)) SWIG_fail;
21364 }
21365 {
21366 arg4 = &temp4;
21367 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21368 }
21369 if (obj4) {
21370 {
21371 arg5 = (int)(SWIG_As_int(obj4));
21372 if (SWIG_arg_fail(5)) SWIG_fail;
21373 }
21374 }
21375 {
21376 PyThreadState* __tstate = wxPyBeginAllowThreads();
21377 (arg1)->DrawComboBoxDropButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
21378
21379 wxPyEndAllowThreads(__tstate);
21380 if (PyErr_Occurred()) SWIG_fail;
21381 }
21382 Py_INCREF(Py_None); resultobj = Py_None;
21383 return resultobj;
21384 fail:
21385 return NULL;
21386 }
21387
21388
21389 static PyObject *_wrap_RendererNative_DrawDropArrow(PyObject *, PyObject *args, PyObject *kwargs) {
21390 PyObject *resultobj;
21391 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21392 wxWindow *arg2 = (wxWindow *) 0 ;
21393 wxDC *arg3 = 0 ;
21394 wxRect *arg4 = 0 ;
21395 int arg5 = (int) 0 ;
21396 wxRect temp4 ;
21397 PyObject * obj0 = 0 ;
21398 PyObject * obj1 = 0 ;
21399 PyObject * obj2 = 0 ;
21400 PyObject * obj3 = 0 ;
21401 PyObject * obj4 = 0 ;
21402 char *kwnames[] = {
21403 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21404 };
21405
21406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawDropArrow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21408 if (SWIG_arg_fail(1)) SWIG_fail;
21409 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21410 if (SWIG_arg_fail(2)) SWIG_fail;
21411 {
21412 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21413 if (SWIG_arg_fail(3)) SWIG_fail;
21414 if (arg3 == NULL) {
21415 SWIG_null_ref("wxDC");
21416 }
21417 if (SWIG_arg_fail(3)) SWIG_fail;
21418 }
21419 {
21420 arg4 = &temp4;
21421 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21422 }
21423 if (obj4) {
21424 {
21425 arg5 = (int)(SWIG_As_int(obj4));
21426 if (SWIG_arg_fail(5)) SWIG_fail;
21427 }
21428 }
21429 {
21430 PyThreadState* __tstate = wxPyBeginAllowThreads();
21431 (arg1)->DrawDropArrow(arg2,*arg3,(wxRect const &)*arg4,arg5);
21432
21433 wxPyEndAllowThreads(__tstate);
21434 if (PyErr_Occurred()) SWIG_fail;
21435 }
21436 Py_INCREF(Py_None); resultobj = Py_None;
21437 return resultobj;
21438 fail:
21439 return NULL;
21440 }
21441
21442
21443 static PyObject *_wrap_RendererNative_GetSplitterParams(PyObject *, PyObject *args, PyObject *kwargs) {
21444 PyObject *resultobj;
21445 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21446 wxWindow *arg2 = (wxWindow *) 0 ;
21447 SwigValueWrapper<wxSplitterRenderParams > result;
21448 PyObject * obj0 = 0 ;
21449 PyObject * obj1 = 0 ;
21450 char *kwnames[] = {
21451 (char *) "self",(char *) "win", NULL
21452 };
21453
21454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RendererNative_GetSplitterParams",kwnames,&obj0,&obj1)) goto fail;
21455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21456 if (SWIG_arg_fail(1)) SWIG_fail;
21457 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21458 if (SWIG_arg_fail(2)) SWIG_fail;
21459 {
21460 PyThreadState* __tstate = wxPyBeginAllowThreads();
21461 result = (arg1)->GetSplitterParams((wxWindow const *)arg2);
21462
21463 wxPyEndAllowThreads(__tstate);
21464 if (PyErr_Occurred()) SWIG_fail;
21465 }
21466 {
21467 wxSplitterRenderParams * resultptr;
21468 resultptr = new wxSplitterRenderParams((wxSplitterRenderParams &)(result));
21469 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSplitterRenderParams, 1);
21470 }
21471 return resultobj;
21472 fail:
21473 return NULL;
21474 }
21475
21476
21477 static PyObject *_wrap_RendererNative_Get(PyObject *, PyObject *args, PyObject *kwargs) {
21478 PyObject *resultobj;
21479 wxRendererNative *result;
21480 char *kwnames[] = {
21481 NULL
21482 };
21483
21484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":RendererNative_Get",kwnames)) goto fail;
21485 {
21486 PyThreadState* __tstate = wxPyBeginAllowThreads();
21487 {
21488 wxRendererNative &_result_ref = wxRendererNative::Get();
21489 result = (wxRendererNative *) &_result_ref;
21490 }
21491
21492 wxPyEndAllowThreads(__tstate);
21493 if (PyErr_Occurred()) SWIG_fail;
21494 }
21495 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
21496 return resultobj;
21497 fail:
21498 return NULL;
21499 }
21500
21501
21502 static PyObject *_wrap_RendererNative_GetGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
21503 PyObject *resultobj;
21504 wxRendererNative *result;
21505 char *kwnames[] = {
21506 NULL
21507 };
21508
21509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":RendererNative_GetGeneric",kwnames)) goto fail;
21510 {
21511 PyThreadState* __tstate = wxPyBeginAllowThreads();
21512 {
21513 wxRendererNative &_result_ref = wxRendererNative::GetGeneric();
21514 result = (wxRendererNative *) &_result_ref;
21515 }
21516
21517 wxPyEndAllowThreads(__tstate);
21518 if (PyErr_Occurred()) SWIG_fail;
21519 }
21520 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
21521 return resultobj;
21522 fail:
21523 return NULL;
21524 }
21525
21526
21527 static PyObject *_wrap_RendererNative_GetDefault(PyObject *, PyObject *args, PyObject *kwargs) {
21528 PyObject *resultobj;
21529 wxRendererNative *result;
21530 char *kwnames[] = {
21531 NULL
21532 };
21533
21534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":RendererNative_GetDefault",kwnames)) goto fail;
21535 {
21536 PyThreadState* __tstate = wxPyBeginAllowThreads();
21537 {
21538 wxRendererNative &_result_ref = wxRendererNative::GetDefault();
21539 result = (wxRendererNative *) &_result_ref;
21540 }
21541
21542 wxPyEndAllowThreads(__tstate);
21543 if (PyErr_Occurred()) SWIG_fail;
21544 }
21545 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
21546 return resultobj;
21547 fail:
21548 return NULL;
21549 }
21550
21551
21552 static PyObject *_wrap_RendererNative_Set(PyObject *, PyObject *args, PyObject *kwargs) {
21553 PyObject *resultobj;
21554 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21555 wxRendererNative *result;
21556 PyObject * obj0 = 0 ;
21557 char *kwnames[] = {
21558 (char *) "renderer", NULL
21559 };
21560
21561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererNative_Set",kwnames,&obj0)) goto fail;
21562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21563 if (SWIG_arg_fail(1)) SWIG_fail;
21564 {
21565 PyThreadState* __tstate = wxPyBeginAllowThreads();
21566 result = (wxRendererNative *)wxRendererNative::Set(arg1);
21567
21568 wxPyEndAllowThreads(__tstate);
21569 if (PyErr_Occurred()) SWIG_fail;
21570 }
21571 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
21572 return resultobj;
21573 fail:
21574 return NULL;
21575 }
21576
21577
21578 static PyObject *_wrap_RendererNative_GetVersion(PyObject *, PyObject *args, PyObject *kwargs) {
21579 PyObject *resultobj;
21580 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21581 SwigValueWrapper<wxRendererVersion > result;
21582 PyObject * obj0 = 0 ;
21583 char *kwnames[] = {
21584 (char *) "self", NULL
21585 };
21586
21587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererNative_GetVersion",kwnames,&obj0)) goto fail;
21588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21589 if (SWIG_arg_fail(1)) SWIG_fail;
21590 {
21591 PyThreadState* __tstate = wxPyBeginAllowThreads();
21592 result = ((wxRendererNative const *)arg1)->GetVersion();
21593
21594 wxPyEndAllowThreads(__tstate);
21595 if (PyErr_Occurred()) SWIG_fail;
21596 }
21597 {
21598 wxRendererVersion * resultptr;
21599 resultptr = new wxRendererVersion((wxRendererVersion &)(result));
21600 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRendererVersion, 1);
21601 }
21602 return resultobj;
21603 fail:
21604 return NULL;
21605 }
21606
21607
21608 static PyObject * RendererNative_swigregister(PyObject *, PyObject *args) {
21609 PyObject *obj;
21610 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21611 SWIG_TypeClientData(SWIGTYPE_p_wxRendererNative, obj);
21612 Py_INCREF(obj);
21613 return Py_BuildValue((char *)"");
21614 }
21615 static PyMethodDef SwigMethods[] = {
21616 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
21617 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
21618 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
21619 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
21620 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
21621 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
21622 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
21623 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
21624 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21625 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
21626 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
21627 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
21628 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
21629 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21630 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21631 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21632 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
21633 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21634 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21635 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21636 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21637 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21638 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
21639 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
21640 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
21641 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21642 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21643 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
21644 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21645 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
21646 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
21647 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
21648 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
21649 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21650 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
21651 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21652 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21653 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21654 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
21655 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21656 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
21657 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21658 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21659 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21660 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21661 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21662 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21663 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21664 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
21665 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
21666 { (char *)"new_BrushFromBitmap", (PyCFunction) _wrap_new_BrushFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21667 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
21668 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21669 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21670 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21671 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21672 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21673 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21674 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
21675 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21676 { (char *)"Brush_MacGetTheme", (PyCFunction) _wrap_Brush_MacGetTheme, METH_VARARGS | METH_KEYWORDS, NULL},
21677 { (char *)"Brush_MacSetTheme", (PyCFunction) _wrap_Brush_MacSetTheme, METH_VARARGS | METH_KEYWORDS, NULL},
21678 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
21679 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21680 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21681 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21682 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21683 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
21684 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
21685 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
21686 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21687 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21688 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21689 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21690 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21691 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
21692 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
21693 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
21694 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
21695 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21696 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
21697 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
21698 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21699 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21700 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21701 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21702 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21703 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21704 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21705 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21706 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
21707 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
21708 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
21709 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
21710 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
21711 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21712 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21713 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21714 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
21715 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21716 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21717 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21718 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21719 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21720 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21721 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21722 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21723 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
21724 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21725 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21726 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21727 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21728 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21729 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
21730 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
21731 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
21732 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
21733 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
21734 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21735 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
21736 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21737 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
21738 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21739 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
21740 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
21741 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
21742 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
21743 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
21744 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21745 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
21746 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
21747 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21748 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
21749 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
21750 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
21751 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21752 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
21753 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
21754 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21755 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
21756 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
21757 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
21758 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
21759 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
21760 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21761 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
21762 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
21763 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
21764 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21765 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
21766 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
21767 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21768 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
21769 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
21770 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21771 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21772 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21773 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
21774 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
21775 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
21776 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
21777 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
21778 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
21779 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
21780 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21781 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
21782 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21783 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
21784 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
21785 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
21786 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
21787 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
21788 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
21789 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21790 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21791 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21792 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
21793 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21794 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21795 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21796 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21797 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21798 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21799 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21800 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21801 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21802 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21803 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21804 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21805 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21806 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21807 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
21808 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
21809 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
21810 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21811 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21812 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
21813 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
21814 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
21815 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
21816 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
21817 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21818 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21819 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
21820 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
21821 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
21822 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21823 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21824 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21825 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21826 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21827 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21828 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21829 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
21830 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21831 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21832 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
21833 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
21834 { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
21835 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21836 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21837 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21838 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
21839 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
21840 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
21841 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
21842 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21843 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21844 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21845 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
21846 { (char *)"new_FFont", (PyCFunction) _wrap_new_FFont, METH_VARARGS | METH_KEYWORDS, NULL},
21847 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21848 { (char *)"new_FFontFromPixelSize", (PyCFunction) _wrap_new_FFontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21849 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21850 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21851 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21852 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21853 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21854 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
21855 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21856 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21857 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21858 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21859 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21860 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21861 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21862 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21863 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21864 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21865 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21866 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21867 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21868 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21869 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21870 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21871 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21872 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21873 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21874 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
21875 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21876 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
21877 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
21878 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
21879 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21880 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21881 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21882 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21883 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
21884 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21885 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21886 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21887 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21888 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21889 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21890 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21891 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
21892 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
21893 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
21894 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
21895 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
21896 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
21897 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
21898 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
21899 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21900 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21901 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
21902 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
21903 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21904 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21905 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21906 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21907 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21908 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21909 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
21910 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
21911 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
21912 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
21913 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
21914 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21915 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
21916 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21917 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21918 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
21919 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
21920 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
21921 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21922 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
21923 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21924 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21925 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21926 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
21927 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21928 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21929 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
21930 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
21931 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
21932 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21933 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21934 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
21935 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21936 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21937 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21938 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
21939 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21940 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
21941 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21942 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
21943 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21944 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
21945 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
21946 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
21947 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21948 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21949 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21950 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21951 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21952 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21953 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21954 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21955 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21956 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
21957 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21958 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
21959 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
21960 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21961 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21962 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21963 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21964 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21965 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
21966 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21967 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
21968 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21969 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
21970 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21971 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21972 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21973 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21974 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21975 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
21976 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
21977 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21978 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21979 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
21980 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21981 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21982 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21983 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
21984 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
21985 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21986 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21987 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21988 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21989 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21990 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21991 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21992 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21993 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21994 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21995 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21996 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21997 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21998 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21999 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
22000 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22001 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
22002 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
22003 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
22004 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
22005 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
22006 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
22007 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
22008 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
22009 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
22010 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
22011 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
22012 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22013 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
22014 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22015 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
22016 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22017 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
22018 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
22019 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22020 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
22021 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
22022 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
22023 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
22024 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
22025 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
22026 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
22027 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
22028 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
22029 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
22030 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
22031 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
22032 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22033 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
22034 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22035 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22036 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22037 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
22038 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22039 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22040 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
22041 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
22042 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
22043 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22044 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
22045 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22046 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
22047 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
22048 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
22049 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
22050 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
22051 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
22052 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
22053 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
22054 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
22055 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
22056 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
22057 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
22058 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
22059 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
22060 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
22061 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
22062 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
22063 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
22064 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
22065 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
22066 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
22067 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
22068 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
22069 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
22070 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
22071 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
22072 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
22073 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
22074 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
22075 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
22076 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
22077 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
22078 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
22079 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
22080 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
22081 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
22082 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
22083 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
22084 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
22085 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
22086 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
22087 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
22088 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
22089 { (char *)"delete_MetaFile", (PyCFunction) _wrap_delete_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
22090 { (char *)"MetaFile_Ok", (PyCFunction) _wrap_MetaFile_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22091 { (char *)"MetaFile_SetClipboard", (PyCFunction) _wrap_MetaFile_SetClipboard, METH_VARARGS | METH_KEYWORDS, NULL},
22092 { (char *)"MetaFile_GetSize", (PyCFunction) _wrap_MetaFile_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22093 { (char *)"MetaFile_GetWidth", (PyCFunction) _wrap_MetaFile_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22094 { (char *)"MetaFile_GetHeight", (PyCFunction) _wrap_MetaFile_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22095 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
22096 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
22097 { (char *)"MetaFileDC_Close", (PyCFunction) _wrap_MetaFileDC_Close, METH_VARARGS | METH_KEYWORDS, NULL},
22098 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
22099 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
22100 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
22101 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
22102 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
22103 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
22104 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
22105 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22106 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22107 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22108 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
22109 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
22110 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
22111 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
22112 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
22113 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22114 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
22115 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
22116 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
22117 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
22118 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
22119 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
22120 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22121 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22122 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22123 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
22124 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
22125 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
22126 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
22127 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
22128 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
22129 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
22130 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
22131 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
22132 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
22133 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
22134 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
22135 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
22136 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
22137 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
22138 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
22139 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22140 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
22141 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22142 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22143 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
22144 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22145 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
22146 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22147 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22148 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
22149 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
22150 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22151 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
22152 { (char *)"new_SplitterRenderParams", (PyCFunction) _wrap_new_SplitterRenderParams, METH_VARARGS | METH_KEYWORDS, NULL},
22153 { (char *)"delete_SplitterRenderParams", (PyCFunction) _wrap_delete_SplitterRenderParams, METH_VARARGS | METH_KEYWORDS, NULL},
22154 { (char *)"SplitterRenderParams_widthSash_get", (PyCFunction) _wrap_SplitterRenderParams_widthSash_get, METH_VARARGS | METH_KEYWORDS, NULL},
22155 { (char *)"SplitterRenderParams_border_get", (PyCFunction) _wrap_SplitterRenderParams_border_get, METH_VARARGS | METH_KEYWORDS, NULL},
22156 { (char *)"SplitterRenderParams_isHotSensitive_get", (PyCFunction) _wrap_SplitterRenderParams_isHotSensitive_get, METH_VARARGS | METH_KEYWORDS, NULL},
22157 { (char *)"SplitterRenderParams_swigregister", SplitterRenderParams_swigregister, METH_VARARGS, NULL},
22158 { (char *)"new_RendererVersion", (PyCFunction) _wrap_new_RendererVersion, METH_VARARGS | METH_KEYWORDS, NULL},
22159 { (char *)"delete_RendererVersion", (PyCFunction) _wrap_delete_RendererVersion, METH_VARARGS | METH_KEYWORDS, NULL},
22160 { (char *)"RendererVersion_IsCompatible", (PyCFunction) _wrap_RendererVersion_IsCompatible, METH_VARARGS | METH_KEYWORDS, NULL},
22161 { (char *)"RendererVersion_version_get", (PyCFunction) _wrap_RendererVersion_version_get, METH_VARARGS | METH_KEYWORDS, NULL},
22162 { (char *)"RendererVersion_age_get", (PyCFunction) _wrap_RendererVersion_age_get, METH_VARARGS | METH_KEYWORDS, NULL},
22163 { (char *)"RendererVersion_swigregister", RendererVersion_swigregister, METH_VARARGS, NULL},
22164 { (char *)"RendererNative_DrawHeaderButton", (PyCFunction) _wrap_RendererNative_DrawHeaderButton, METH_VARARGS | METH_KEYWORDS, NULL},
22165 { (char *)"RendererNative_DrawTreeItemButton", (PyCFunction) _wrap_RendererNative_DrawTreeItemButton, METH_VARARGS | METH_KEYWORDS, NULL},
22166 { (char *)"RendererNative_DrawSplitterBorder", (PyCFunction) _wrap_RendererNative_DrawSplitterBorder, METH_VARARGS | METH_KEYWORDS, NULL},
22167 { (char *)"RendererNative_DrawSplitterSash", (PyCFunction) _wrap_RendererNative_DrawSplitterSash, METH_VARARGS | METH_KEYWORDS, NULL},
22168 { (char *)"RendererNative_DrawComboBoxDropButton", (PyCFunction) _wrap_RendererNative_DrawComboBoxDropButton, METH_VARARGS | METH_KEYWORDS, NULL},
22169 { (char *)"RendererNative_DrawDropArrow", (PyCFunction) _wrap_RendererNative_DrawDropArrow, METH_VARARGS | METH_KEYWORDS, NULL},
22170 { (char *)"RendererNative_GetSplitterParams", (PyCFunction) _wrap_RendererNative_GetSplitterParams, METH_VARARGS | METH_KEYWORDS, NULL},
22171 { (char *)"RendererNative_Get", (PyCFunction) _wrap_RendererNative_Get, METH_VARARGS | METH_KEYWORDS, NULL},
22172 { (char *)"RendererNative_GetGeneric", (PyCFunction) _wrap_RendererNative_GetGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
22173 { (char *)"RendererNative_GetDefault", (PyCFunction) _wrap_RendererNative_GetDefault, METH_VARARGS | METH_KEYWORDS, NULL},
22174 { (char *)"RendererNative_Set", (PyCFunction) _wrap_RendererNative_Set, METH_VARARGS | METH_KEYWORDS, NULL},
22175 { (char *)"RendererNative_GetVersion", (PyCFunction) _wrap_RendererNative_GetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
22176 { (char *)"RendererNative_swigregister", RendererNative_swigregister, METH_VARARGS, NULL},
22177 { NULL, NULL, 0, NULL }
22178 };
22179
22180
22181 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22182
22183 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
22184 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
22185 }
22186 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
22187 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
22188 }
22189 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
22190 return (void *)((wxGDIObject *) ((wxIcon *) x));
22191 }
22192 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
22193 return (void *)((wxGDIObject *) ((wxPalette *) x));
22194 }
22195 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
22196 return (void *)((wxGDIObject *) ((wxPen *) x));
22197 }
22198 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
22199 return (void *)((wxGDIObject *) ((wxFont *) x));
22200 }
22201 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
22202 return (void *)((wxGDIObject *) ((wxCursor *) x));
22203 }
22204 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
22205 return (void *)((wxGDIObject *) ((wxBitmap *) x));
22206 }
22207 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
22208 return (void *)((wxGDIObject *) ((wxRegion *) x));
22209 }
22210 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
22211 return (void *)((wxGDIObject *) ((wxBrush *) x));
22212 }
22213 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
22214 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
22215 }
22216 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
22217 return (void *)((wxDC *) ((wxScreenDC *) x));
22218 }
22219 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
22220 return (void *)((wxDC *) ((wxMirrorDC *) x));
22221 }
22222 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
22223 return (void *)((wxDC *) ((wxMemoryDC *) x));
22224 }
22225 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
22226 return (void *)((wxDC *) ((wxWindowDC *) x));
22227 }
22228 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
22229 return (void *)((wxDC *) ((wxMetaFileDC *) x));
22230 }
22231 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
22232 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
22233 }
22234 static void *_p_wxClientDCTo_p_wxDC(void *x) {
22235 return (void *)((wxDC *) ((wxClientDC *) x));
22236 }
22237 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
22238 return (void *)((wxDC *) ((wxPaintDC *) x));
22239 }
22240 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
22241 return (void *)((wxDC *) ((wxPostScriptDC *) x));
22242 }
22243 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
22244 return (void *)((wxDC *) ((wxPrinterDC *) x));
22245 }
22246 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
22247 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
22248 }
22249 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
22250 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
22251 }
22252 static void *_p_wxPenTo_p_wxObject(void *x) {
22253 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
22254 }
22255 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
22256 return (void *)((wxObject *) ((wxRegionIterator *) x));
22257 }
22258 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
22259 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
22260 }
22261 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
22262 return (void *)((wxObject *) ((wxSizerItem *) x));
22263 }
22264 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
22265 return (void *)((wxObject *) ((wxColourDatabase *) x));
22266 }
22267 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
22268 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
22269 }
22270 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
22271 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
22272 }
22273 static void *_p_wxIconTo_p_wxObject(void *x) {
22274 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
22275 }
22276 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
22277 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
22278 }
22279 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
22280 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
22281 }
22282 static void *_p_wxSizerTo_p_wxObject(void *x) {
22283 return (void *)((wxObject *) ((wxSizer *) x));
22284 }
22285 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
22286 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
22287 }
22288 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
22289 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
22290 }
22291 static void *_p_wxPenListTo_p_wxObject(void *x) {
22292 return (void *)((wxObject *) ((wxPenList *) x));
22293 }
22294 static void *_p_wxEventTo_p_wxObject(void *x) {
22295 return (void *)((wxObject *) ((wxEvent *) x));
22296 }
22297 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
22298 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
22299 }
22300 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
22301 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
22302 }
22303 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
22304 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
22305 }
22306 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
22307 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
22308 }
22309 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
22310 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
22311 }
22312 static void *_p_wxDCTo_p_wxObject(void *x) {
22313 return (void *)((wxObject *) ((wxDC *) x));
22314 }
22315 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
22316 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
22317 }
22318 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
22319 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
22320 }
22321 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
22322 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
22323 }
22324 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
22325 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
22326 }
22327 static void *_p_wxControlTo_p_wxObject(void *x) {
22328 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
22329 }
22330 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
22331 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
22332 }
22333 static void *_p_wxClientDCTo_p_wxObject(void *x) {
22334 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
22335 }
22336 static void *_p_wxFSFileTo_p_wxObject(void *x) {
22337 return (void *)((wxObject *) ((wxFSFile *) x));
22338 }
22339 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
22340 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
22341 }
22342 static void *_p_wxRegionTo_p_wxObject(void *x) {
22343 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
22344 }
22345 static void *_p_wxPySizerTo_p_wxObject(void *x) {
22346 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
22347 }
22348 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
22349 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
22350 }
22351 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
22352 return (void *)((wxObject *) ((wxGDIObject *) x));
22353 }
22354 static void *_p_wxEffectsTo_p_wxObject(void *x) {
22355 return (void *)((wxObject *) ((wxEffects *) x));
22356 }
22357 static void *_p_wxPyEventTo_p_wxObject(void *x) {
22358 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
22359 }
22360 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
22361 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
22362 }
22363 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
22364 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
22365 }
22366 static void *_p_wxShowEventTo_p_wxObject(void *x) {
22367 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
22368 }
22369 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
22370 return (void *)((wxObject *) ((wxMenuItem *) x));
22371 }
22372 static void *_p_wxDateEventTo_p_wxObject(void *x) {
22373 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
22374 }
22375 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
22376 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
22377 }
22378 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
22379 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
22380 }
22381 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
22382 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
22383 }
22384 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
22385 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
22386 }
22387 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
22388 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
22389 }
22390 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
22391 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
22392 }
22393 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
22394 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
22395 }
22396 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
22397 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
22398 }
22399 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
22400 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
22401 }
22402 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
22403 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
22404 }
22405 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
22406 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
22407 }
22408 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
22409 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
22410 }
22411 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
22412 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
22413 }
22414 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
22415 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
22416 }
22417 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
22418 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
22419 }
22420 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
22421 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
22422 }
22423 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
22424 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
22425 }
22426 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
22427 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
22428 }
22429 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
22430 return (void *)((wxObject *) ((wxImageHandler *) x));
22431 }
22432 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
22433 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
22434 }
22435 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
22436 return (void *)((wxObject *) ((wxEvtHandler *) x));
22437 }
22438 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
22439 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
22440 }
22441 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
22442 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
22443 }
22444 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
22445 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
22446 }
22447 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
22448 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
22449 }
22450 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
22451 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
22452 }
22453 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
22454 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
22455 }
22456 static void *_p_wxImageTo_p_wxObject(void *x) {
22457 return (void *)((wxObject *) ((wxImage *) x));
22458 }
22459 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
22460 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
22461 }
22462 static void *_p_wxPaletteTo_p_wxObject(void *x) {
22463 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
22464 }
22465 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
22466 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
22467 }
22468 static void *_p_wxImageListTo_p_wxObject(void *x) {
22469 return (void *)((wxObject *) ((wxImageList *) x));
22470 }
22471 static void *_p_wxCursorTo_p_wxObject(void *x) {
22472 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
22473 }
22474 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
22475 return (void *)((wxObject *) ((wxEncodingConverter *) x));
22476 }
22477 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
22478 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
22479 }
22480 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
22481 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
22482 }
22483 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
22484 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
22485 }
22486 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
22487 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
22488 }
22489 static void *_p_wxWindowTo_p_wxObject(void *x) {
22490 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
22491 }
22492 static void *_p_wxMenuTo_p_wxObject(void *x) {
22493 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
22494 }
22495 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
22496 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
22497 }
22498 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
22499 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
22500 }
22501 static void *_p_wxBrushListTo_p_wxObject(void *x) {
22502 return (void *)((wxObject *) ((wxBrushList *) x));
22503 }
22504 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
22505 return (void *)((wxObject *) ((wxFileSystem *) x));
22506 }
22507 static void *_p_wxBitmapTo_p_wxObject(void *x) {
22508 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
22509 }
22510 static void *_p_wxMaskTo_p_wxObject(void *x) {
22511 return (void *)((wxObject *) ((wxMask *) x));
22512 }
22513 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
22514 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
22515 }
22516 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
22517 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
22518 }
22519 static void *_p_wxPyAppTo_p_wxObject(void *x) {
22520 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
22521 }
22522 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
22523 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
22524 }
22525 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
22526 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
22527 }
22528 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
22529 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
22530 }
22531 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
22532 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
22533 }
22534 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
22535 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
22536 }
22537 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
22538 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
22539 }
22540 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
22541 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
22542 }
22543 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
22544 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
22545 }
22546 static void *_p_wxFontTo_p_wxObject(void *x) {
22547 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
22548 }
22549 static void *_p_wxBrushTo_p_wxObject(void *x) {
22550 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
22551 }
22552 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
22553 return (void *)((wxObject *) ((wxMetaFile *) x));
22554 }
22555 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
22556 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
22557 }
22558 static void *_p_wxColourTo_p_wxObject(void *x) {
22559 return (void *)((wxObject *) ((wxColour *) x));
22560 }
22561 static void *_p_wxFontListTo_p_wxObject(void *x) {
22562 return (void *)((wxObject *) ((wxFontList *) x));
22563 }
22564 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
22565 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
22566 }
22567 static void *_p_wxValidatorTo_p_wxObject(void *x) {
22568 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
22569 }
22570 static void *_p_wxControlTo_p_wxWindow(void *x) {
22571 return (void *)((wxWindow *) ((wxControl *) x));
22572 }
22573 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
22574 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
22575 }
22576 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
22577 return (void *)((wxWindow *) ((wxMenuBar *) x));
22578 }
22579 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}};
22580 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}};
22581 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}};
22582 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}};
22583 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}};
22584 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}};
22585 static swig_type_info _swigt__p_wxRendererVersion[] = {{"_p_wxRendererVersion", 0, "wxRendererVersion *", 0, 0, 0, 0},{"_p_wxRendererVersion", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
22586 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}};
22587 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}};
22588 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}};
22589 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}};
22590 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}};
22591 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}};
22592 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}};
22593 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}};
22594 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}};
22595 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}};
22596 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}};
22597 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}};
22598 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}};
22599 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}};
22600 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}};
22601 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}};
22602 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}};
22603 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}};
22604 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}};
22605 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}};
22606 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}};
22607 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}};
22608 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}};
22609 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}};
22610 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}};
22611 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}};
22612 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}};
22613 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}};
22614 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}};
22615 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}};
22616 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}};
22617 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}};
22618 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}};
22619 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}};
22620 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}};
22621 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}};
22622 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}};
22623 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}};
22624 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}};
22625 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}};
22626 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}};
22627 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}};
22628 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}};
22629 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}};
22630 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}};
22631 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}};
22632 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}};
22633 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}};
22634 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}};
22635 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}};
22636 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}};
22637 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}};
22638 static swig_type_info _swigt__p_wxRendererNative[] = {{"_p_wxRendererNative", 0, "wxRendererNative *", 0, 0, 0, 0},{"_p_wxRendererNative", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
22639 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}};
22640 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}};
22641 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}};
22642 static swig_type_info _swigt__p_wxSplitterRenderParams[] = {{"_p_wxSplitterRenderParams", 0, "wxSplitterRenderParams *", 0, 0, 0, 0},{"_p_wxSplitterRenderParams", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
22643 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}};
22644
22645 static swig_type_info *swig_types_initial[] = {
22646 _swigt__p_wxPostScriptDC,
22647 _swigt__p_wxBrush,
22648 _swigt__p_wxColour,
22649 _swigt__p_wxDC,
22650 _swigt__p_wxMirrorDC,
22651 _swigt__p_form_ops_t,
22652 _swigt__p_wxRendererVersion,
22653 _swigt__p_wxDuplexMode,
22654 _swigt__p_wxPyFontEnumerator,
22655 _swigt__p_char,
22656 _swigt__p_wxIconLocation,
22657 _swigt__p_wxImage,
22658 _swigt__p_wxMetaFileDC,
22659 _swigt__p_wxMask,
22660 _swigt__p_wxSize,
22661 _swigt__p_wxFont,
22662 _swigt__p_wxWindow,
22663 _swigt__p_double,
22664 _swigt__p_wxMemoryDC,
22665 _swigt__p_wxFontMapper,
22666 _swigt__p_wxEffects,
22667 _swigt__p_wxNativeEncodingInfo,
22668 _swigt__p_wxPalette,
22669 _swigt__p_wxBitmap,
22670 _swigt__p_wxObject,
22671 _swigt__p_wxRegionIterator,
22672 _swigt__p_wxRect,
22673 _swigt__p_wxPaperSize,
22674 _swigt__p_wxString,
22675 _swigt__unsigned_int,
22676 _swigt__p_unsigned_int,
22677 _swigt__p_wxPrinterDC,
22678 _swigt__p_wxIconBundle,
22679 _swigt__p_wxPoint,
22680 _swigt__p_wxDash,
22681 _swigt__p_wxScreenDC,
22682 _swigt__p_wxCursor,
22683 _swigt__p_wxClientDC,
22684 _swigt__p_wxBufferedDC,
22685 _swigt__p_wxImageList,
22686 _swigt__p_unsigned_char,
22687 _swigt__p_wxGDIObject,
22688 _swigt__p_wxIcon,
22689 _swigt__p_wxLocale,
22690 _swigt__ptrdiff_t,
22691 _swigt__std__ptrdiff_t,
22692 _swigt__p_wxRegion,
22693 _swigt__p_wxConfigBase,
22694 _swigt__p_wxLanguageInfo,
22695 _swigt__p_wxWindowDC,
22696 _swigt__p_wxPrintData,
22697 _swigt__p_wxBrushList,
22698 _swigt__p_wxFontList,
22699 _swigt__p_wxPen,
22700 _swigt__p_wxBufferedPaintDC,
22701 _swigt__p_wxPaintDC,
22702 _swigt__p_wxPenList,
22703 _swigt__p_int,
22704 _swigt__p_wxMetaFile,
22705 _swigt__p_wxRendererNative,
22706 _swigt__p_unsigned_long,
22707 _swigt__p_wxNativeFontInfo,
22708 _swigt__p_wxEncodingConverter,
22709 _swigt__p_wxSplitterRenderParams,
22710 _swigt__p_wxColourDatabase,
22711 0
22712 };
22713
22714
22715 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22716
22717 static swig_const_info swig_const_table[] = {
22718 {0, 0, 0, 0.0, 0, 0}};
22719
22720 #ifdef __cplusplus
22721 }
22722 #endif
22723
22724
22725 #ifdef __cplusplus
22726 extern "C" {
22727 #endif
22728
22729 /* Python-specific SWIG API */
22730 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22731 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22732 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22733
22734 /* -----------------------------------------------------------------------------
22735 * global variable support code.
22736 * ----------------------------------------------------------------------------- */
22737
22738 typedef struct swig_globalvar {
22739 char *name; /* Name of global variable */
22740 PyObject *(*get_attr)(); /* Return the current value */
22741 int (*set_attr)(PyObject *); /* Set the value */
22742 struct swig_globalvar *next;
22743 } swig_globalvar;
22744
22745 typedef struct swig_varlinkobject {
22746 PyObject_HEAD
22747 swig_globalvar *vars;
22748 } swig_varlinkobject;
22749
22750 static PyObject *
22751 swig_varlink_repr(swig_varlinkobject *v) {
22752 v = v;
22753 return PyString_FromString("<Swig global variables>");
22754 }
22755
22756 static int
22757 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
22758 swig_globalvar *var;
22759 flags = flags;
22760 fprintf(fp,"Swig global variables { ");
22761 for (var = v->vars; var; var=var->next) {
22762 fprintf(fp,"%s", var->name);
22763 if (var->next) fprintf(fp,", ");
22764 }
22765 fprintf(fp," }\n");
22766 return 0;
22767 }
22768
22769 static PyObject *
22770 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
22771 swig_globalvar *var = v->vars;
22772 while (var) {
22773 if (strcmp(var->name,n) == 0) {
22774 return (*var->get_attr)();
22775 }
22776 var = var->next;
22777 }
22778 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22779 return NULL;
22780 }
22781
22782 static int
22783 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22784 swig_globalvar *var = v->vars;
22785 while (var) {
22786 if (strcmp(var->name,n) == 0) {
22787 return (*var->set_attr)(p);
22788 }
22789 var = var->next;
22790 }
22791 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22792 return 1;
22793 }
22794
22795 static PyTypeObject varlinktype = {
22796 PyObject_HEAD_INIT(0)
22797 0, /* Number of items in variable part (ob_size) */
22798 (char *)"swigvarlink", /* Type name (tp_name) */
22799 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
22800 0, /* Itemsize (tp_itemsize) */
22801 0, /* Deallocator (tp_dealloc) */
22802 (printfunc) swig_varlink_print, /* Print (tp_print) */
22803 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
22804 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
22805 0, /* tp_compare */
22806 (reprfunc) swig_varlink_repr, /* tp_repr */
22807 0, /* tp_as_number */
22808 0, /* tp_as_sequence */
22809 0, /* tp_as_mapping */
22810 0, /* tp_hash */
22811 0, /* tp_call */
22812 0, /* tp_str */
22813 0, /* tp_getattro */
22814 0, /* tp_setattro */
22815 0, /* tp_as_buffer */
22816 0, /* tp_flags */
22817 0, /* tp_doc */
22818 #if PY_VERSION_HEX >= 0x02000000
22819 0, /* tp_traverse */
22820 0, /* tp_clear */
22821 #endif
22822 #if PY_VERSION_HEX >= 0x02010000
22823 0, /* tp_richcompare */
22824 0, /* tp_weaklistoffset */
22825 #endif
22826 #if PY_VERSION_HEX >= 0x02020000
22827 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22828 #endif
22829 #if PY_VERSION_HEX >= 0x02030000
22830 0, /* tp_del */
22831 #endif
22832 #ifdef COUNT_ALLOCS
22833 0,0,0,0 /* tp_alloc -> tp_next */
22834 #endif
22835 };
22836
22837 /* Create a variable linking object for use later */
22838 static PyObject *
22839 SWIG_Python_newvarlink(void) {
22840 swig_varlinkobject *result = 0;
22841 result = PyMem_NEW(swig_varlinkobject,1);
22842 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
22843 result->ob_type = &varlinktype;
22844 result->vars = 0;
22845 result->ob_refcnt = 0;
22846 Py_XINCREF((PyObject *) result);
22847 return ((PyObject*) result);
22848 }
22849
22850 static void
22851 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22852 swig_varlinkobject *v;
22853 swig_globalvar *gv;
22854 v= (swig_varlinkobject *) p;
22855 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22856 gv->name = (char *) malloc(strlen(name)+1);
22857 strcpy(gv->name,name);
22858 gv->get_attr = get_attr;
22859 gv->set_attr = set_attr;
22860 gv->next = v->vars;
22861 v->vars = gv;
22862 }
22863
22864 /* -----------------------------------------------------------------------------
22865 * constants/methods manipulation
22866 * ----------------------------------------------------------------------------- */
22867
22868 /* Install Constants */
22869 static void
22870 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22871 PyObject *obj = 0;
22872 size_t i;
22873 for (i = 0; constants[i].type; i++) {
22874 switch(constants[i].type) {
22875 case SWIG_PY_INT:
22876 obj = PyInt_FromLong(constants[i].lvalue);
22877 break;
22878 case SWIG_PY_FLOAT:
22879 obj = PyFloat_FromDouble(constants[i].dvalue);
22880 break;
22881 case SWIG_PY_STRING:
22882 if (constants[i].pvalue) {
22883 obj = PyString_FromString((char *) constants[i].pvalue);
22884 } else {
22885 Py_INCREF(Py_None);
22886 obj = Py_None;
22887 }
22888 break;
22889 case SWIG_PY_POINTER:
22890 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22891 break;
22892 case SWIG_PY_BINARY:
22893 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22894 break;
22895 default:
22896 obj = 0;
22897 break;
22898 }
22899 if (obj) {
22900 PyDict_SetItemString(d,constants[i].name,obj);
22901 Py_DECREF(obj);
22902 }
22903 }
22904 }
22905
22906 /* -----------------------------------------------------------------------------*/
22907 /* Fix SwigMethods to carry the callback ptrs when needed */
22908 /* -----------------------------------------------------------------------------*/
22909
22910 static void
22911 SWIG_Python_FixMethods(PyMethodDef *methods,
22912 swig_const_info *const_table,
22913 swig_type_info **types,
22914 swig_type_info **types_initial) {
22915 size_t i;
22916 for (i = 0; methods[i].ml_name; ++i) {
22917 char *c = methods[i].ml_doc;
22918 if (c && (c = strstr(c, "swig_ptr: "))) {
22919 int j;
22920 swig_const_info *ci = 0;
22921 char *name = c + 10;
22922 for (j = 0; const_table[j].type; j++) {
22923 if (strncmp(const_table[j].name, name,
22924 strlen(const_table[j].name)) == 0) {
22925 ci = &(const_table[j]);
22926 break;
22927 }
22928 }
22929 if (ci) {
22930 size_t shift = (ci->ptype) - types;
22931 swig_type_info *ty = types_initial[shift];
22932 size_t ldoc = (c - methods[i].ml_doc);
22933 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22934 char *ndoc = (char*)malloc(ldoc + lptr + 10);
22935 char *buff = ndoc;
22936 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
22937 strncpy(buff, methods[i].ml_doc, ldoc);
22938 buff += ldoc;
22939 strncpy(buff, "swig_ptr: ", 10);
22940 buff += 10;
22941 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22942 methods[i].ml_doc = ndoc;
22943 }
22944 }
22945 }
22946 }
22947
22948 /* -----------------------------------------------------------------------------*
22949 * Initialize type list
22950 * -----------------------------------------------------------------------------*/
22951
22952 #if PY_MAJOR_VERSION < 2
22953 /* PyModule_AddObject function was introduced in Python 2.0. The following function
22954 is copied out of Python/modsupport.c in python version 2.3.4 */
22955 static int
22956 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
22957 {
22958 PyObject *dict;
22959 if (!PyModule_Check(m)) {
22960 PyErr_SetString(PyExc_TypeError,
22961 "PyModule_AddObject() needs module as first arg");
22962 return -1;
22963 }
22964 if (!o) {
22965 PyErr_SetString(PyExc_TypeError,
22966 "PyModule_AddObject() needs non-NULL value");
22967 return -1;
22968 }
22969
22970 dict = PyModule_GetDict(m);
22971 if (dict == NULL) {
22972 /* Internal error -- modules must have a dict! */
22973 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
22974 PyModule_GetName(m));
22975 return -1;
22976 }
22977 if (PyDict_SetItemString(dict, name, o))
22978 return -1;
22979 Py_DECREF(o);
22980 return 0;
22981 }
22982 #endif
22983
22984 static swig_type_info **
22985 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
22986 static PyMethodDef swig_empty_runtime_method_table[] = {
22987 {
22988 NULL, NULL, 0, NULL
22989 }
22990 };/* Sentinel */
22991
22992 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
22993 swig_empty_runtime_method_table);
22994 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
22995 if (pointer && module) {
22996 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
22997 }
22998 return type_list_handle;
22999 }
23000
23001 static swig_type_info **
23002 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
23003 swig_type_info **type_pointer;
23004
23005 /* first check if module already created */
23006 type_pointer = SWIG_Python_GetTypeListHandle();
23007 if (type_pointer) {
23008 return type_pointer;
23009 } else {
23010 /* create a new module and variable */
23011 return SWIG_Python_SetTypeListHandle(type_list_handle);
23012 }
23013 }
23014
23015 #ifdef __cplusplus
23016 }
23017 #endif
23018
23019 /* -----------------------------------------------------------------------------*
23020 * Partial Init method
23021 * -----------------------------------------------------------------------------*/
23022
23023 #ifdef SWIG_LINK_RUNTIME
23024 #ifdef __cplusplus
23025 extern "C"
23026 #endif
23027 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
23028 #endif
23029
23030 #ifdef __cplusplus
23031 extern "C"
23032 #endif
23033 SWIGEXPORT(void) SWIG_init(void) {
23034 static PyObject *SWIG_globals = 0;
23035 static int typeinit = 0;
23036 PyObject *m, *d;
23037 int i;
23038 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
23039
23040 /* Fix SwigMethods to carry the callback ptrs when needed */
23041 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
23042
23043 m = Py_InitModule((char *) SWIG_name, SwigMethods);
23044 d = PyModule_GetDict(m);
23045
23046 if (!typeinit) {
23047 #ifdef SWIG_LINK_RUNTIME
23048 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
23049 #else
23050 # ifndef SWIG_STATIC_RUNTIME
23051 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
23052 # endif
23053 #endif
23054 for (i = 0; swig_types_initial[i]; i++) {
23055 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
23056 }
23057 typeinit = 1;
23058 }
23059 SWIG_InstallConstants(d,swig_const_table);
23060
23061 {
23062 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
23063 }
23064 {
23065 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
23066 }
23067 {
23068 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
23069 }
23070 {
23071 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
23072 }
23073 {
23074 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
23075 }
23076 {
23077 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
23078 }
23079 {
23080 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
23081 }
23082 {
23083 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
23084 }
23085 {
23086 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
23087 }
23088 {
23089 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
23090 }
23091 {
23092 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
23093 }
23094 {
23095 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
23096 }
23097 {
23098 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
23099 }
23100 {
23101 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
23102 }
23103 {
23104 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
23105 }
23106 {
23107 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
23108 }
23109 {
23110 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
23111 }
23112 {
23113 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
23114 }
23115 {
23116 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
23117 }
23118 {
23119 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
23120 }
23121 {
23122 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
23123 }
23124 {
23125 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
23126 }
23127 {
23128 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
23129 }
23130 {
23131 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
23132 }
23133 {
23134 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
23135 }
23136 {
23137 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
23138 }
23139 {
23140 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
23141 }
23142 {
23143 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
23144 }
23145 {
23146 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
23147 }
23148 {
23149 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
23150 }
23151 {
23152 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
23153 }
23154 {
23155 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
23156 }
23157 {
23158 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
23159 }
23160 {
23161 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
23162 }
23163 {
23164 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
23165 }
23166 {
23167 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
23168 }
23169 {
23170 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
23171 }
23172 {
23173 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
23174 }
23175 {
23176 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
23177 }
23178 {
23179 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
23180 }
23181 {
23182 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
23183 }
23184 {
23185 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
23186 }
23187 {
23188 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
23189 }
23190 {
23191 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
23192 }
23193 {
23194 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
23195 }
23196 {
23197 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
23198 }
23199 {
23200 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
23201 }
23202 {
23203 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
23204 }
23205 {
23206 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
23207 }
23208 {
23209 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
23210 }
23211 {
23212 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
23213 }
23214 {
23215 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
23216 }
23217 {
23218 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
23219 }
23220 {
23221 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
23222 }
23223 {
23224 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
23225 }
23226 {
23227 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
23228 }
23229 {
23230 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
23231 }
23232 {
23233 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
23234 }
23235 {
23236 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
23237 }
23238 {
23239 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
23240 }
23241 {
23242 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
23243 }
23244 {
23245 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
23246 }
23247 {
23248 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
23249 }
23250 {
23251 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
23252 }
23253 {
23254 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
23255 }
23256 {
23257 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
23258 }
23259 {
23260 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
23261 }
23262 {
23263 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
23264 }
23265 {
23266 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
23267 }
23268 {
23269 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
23270 }
23271 {
23272 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
23273 }
23274 {
23275 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
23276 }
23277 {
23278 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
23279 }
23280 {
23281 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
23282 }
23283 {
23284 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
23285 }
23286 {
23287 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
23288 }
23289 {
23290 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
23291 }
23292 {
23293 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
23294 }
23295 {
23296 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
23297 }
23298 {
23299 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
23300 }
23301 {
23302 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
23303 }
23304 {
23305 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
23306 }
23307 {
23308 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
23309 }
23310 {
23311 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
23312 }
23313 {
23314 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
23315 }
23316 {
23317 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
23318 }
23319 {
23320 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
23321 }
23322 {
23323 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
23324 }
23325 {
23326 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
23327 }
23328 {
23329 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
23330 }
23331 {
23332 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
23333 }
23334 {
23335 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
23336 }
23337 {
23338 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
23339 }
23340 {
23341 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
23342 }
23343 {
23344 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
23345 }
23346 {
23347 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
23348 }
23349 {
23350 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
23351 }
23352 {
23353 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
23354 }
23355 {
23356 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
23357 }
23358 {
23359 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
23360 }
23361 {
23362 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
23363 }
23364 {
23365 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
23366 }
23367 {
23368 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
23369 }
23370 {
23371 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
23372 }
23373 {
23374 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
23375 }
23376 {
23377 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
23378 }
23379 {
23380 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
23381 }
23382 {
23383 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
23384 }
23385 {
23386 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
23387 }
23388 {
23389 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
23390 }
23391 {
23392 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
23393 }
23394 {
23395 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
23396 }
23397 {
23398 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
23399 }
23400 {
23401 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
23402 }
23403 {
23404 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
23405 }
23406 {
23407 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
23408 }
23409 {
23410 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
23411 }
23412 {
23413 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
23414 }
23415 {
23416 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
23417 }
23418 {
23419 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
23420 }
23421 {
23422 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
23423 }
23424 {
23425 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
23426 }
23427 {
23428 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
23429 }
23430 {
23431 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
23432 }
23433 {
23434 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
23435 }
23436 {
23437 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
23438 }
23439 {
23440 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
23441 }
23442
23443 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
23444
23445 {
23446 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
23447 }
23448 {
23449 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
23450 }
23451 {
23452 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
23453 }
23454 {
23455 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
23456 }
23457 {
23458 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
23459 }
23460 {
23461 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
23462 }
23463 {
23464 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
23465 }
23466 {
23467 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
23468 }
23469 {
23470 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
23471 }
23472 {
23473 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
23474 }
23475 {
23476 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
23477 }
23478 {
23479 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
23480 }
23481 {
23482 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
23483 }
23484 {
23485 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
23486 }
23487 {
23488 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
23489 }
23490 {
23491 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
23492 }
23493 {
23494 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
23495 }
23496 {
23497 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
23498 }
23499 {
23500 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
23501 }
23502 {
23503 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
23504 }
23505 {
23506 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
23507 }
23508 {
23509 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
23510 }
23511 {
23512 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
23513 }
23514 {
23515 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
23516 }
23517 {
23518 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
23519 }
23520 {
23521 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
23522 }
23523 {
23524 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
23525 }
23526 {
23527 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
23528 }
23529 {
23530 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
23531 }
23532 {
23533 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
23534 }
23535 {
23536 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
23537 }
23538 {
23539 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
23540 }
23541 {
23542 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
23543 }
23544 {
23545 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
23546 }
23547 {
23548 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
23549 }
23550 {
23551 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
23552 }
23553 {
23554 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
23555 }
23556 {
23557 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
23558 }
23559 {
23560 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
23561 }
23562 {
23563 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
23564 }
23565 {
23566 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
23567 }
23568 {
23569 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
23570 }
23571 {
23572 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
23573 }
23574 {
23575 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
23576 }
23577 {
23578 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
23579 }
23580 {
23581 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
23582 }
23583 {
23584 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
23585 }
23586 {
23587 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
23588 }
23589 {
23590 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
23591 }
23592 {
23593 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
23594 }
23595 {
23596 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
23597 }
23598 {
23599 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
23600 }
23601 {
23602 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
23603 }
23604 {
23605 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
23606 }
23607 {
23608 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
23609 }
23610 {
23611 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
23612 }
23613 {
23614 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
23615 }
23616 {
23617 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
23618 }
23619 {
23620 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
23621 }
23622 {
23623 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
23624 }
23625 {
23626 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
23627 }
23628 {
23629 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
23630 }
23631 {
23632 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
23633 }
23634 {
23635 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
23636 }
23637 {
23638 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
23639 }
23640 {
23641 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
23642 }
23643 {
23644 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
23645 }
23646 {
23647 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
23648 }
23649 {
23650 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
23651 }
23652 {
23653 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
23654 }
23655 {
23656 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
23657 }
23658 {
23659 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
23660 }
23661 {
23662 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
23663 }
23664 {
23665 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
23666 }
23667 {
23668 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
23669 }
23670 {
23671 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
23672 }
23673 {
23674 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
23675 }
23676 {
23677 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
23678 }
23679 {
23680 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
23681 }
23682 {
23683 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
23684 }
23685 {
23686 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
23687 }
23688 {
23689 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
23690 }
23691 {
23692 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
23693 }
23694 {
23695 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
23696 }
23697 {
23698 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
23699 }
23700 {
23701 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
23702 }
23703 {
23704 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
23705 }
23706 {
23707 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
23708 }
23709 {
23710 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
23711 }
23712 {
23713 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
23714 }
23715 {
23716 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
23717 }
23718 {
23719 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
23720 }
23721 {
23722 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
23723 }
23724 {
23725 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
23726 }
23727 {
23728 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
23729 }
23730 {
23731 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
23732 }
23733 {
23734 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
23735 }
23736 {
23737 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
23738 }
23739 {
23740 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
23741 }
23742 {
23743 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
23744 }
23745 {
23746 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
23747 }
23748 {
23749 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
23750 }
23751 {
23752 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
23753 }
23754 {
23755 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
23756 }
23757 {
23758 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
23759 }
23760 {
23761 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
23762 }
23763 {
23764 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
23765 }
23766 {
23767 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
23768 }
23769 {
23770 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
23771 }
23772 {
23773 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
23774 }
23775 {
23776 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
23777 }
23778 {
23779 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
23780 }
23781 {
23782 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
23783 }
23784 {
23785 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
23786 }
23787 {
23788 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
23789 }
23790 {
23791 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
23792 }
23793 {
23794 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
23795 }
23796 {
23797 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
23798 }
23799 {
23800 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
23801 }
23802 {
23803 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
23804 }
23805 {
23806 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
23807 }
23808 {
23809 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
23810 }
23811 {
23812 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
23813 }
23814 {
23815 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
23816 }
23817 {
23818 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
23819 }
23820 {
23821 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
23822 }
23823 {
23824 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
23825 }
23826 {
23827 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
23828 }
23829 {
23830 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
23831 }
23832 {
23833 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
23834 }
23835 {
23836 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
23837 }
23838 {
23839 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
23840 }
23841 {
23842 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
23843 }
23844 {
23845 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
23846 }
23847 {
23848 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
23849 }
23850 {
23851 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
23852 }
23853 {
23854 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
23855 }
23856 {
23857 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
23858 }
23859 {
23860 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
23861 }
23862 {
23863 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
23864 }
23865 {
23866 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
23867 }
23868 {
23869 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
23870 }
23871 {
23872 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
23873 }
23874 {
23875 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
23876 }
23877 {
23878 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
23879 }
23880 {
23881 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
23882 }
23883 {
23884 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
23885 }
23886 {
23887 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
23888 }
23889 {
23890 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
23891 }
23892 {
23893 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
23894 }
23895 {
23896 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
23897 }
23898 {
23899 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
23900 }
23901 {
23902 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
23903 }
23904 {
23905 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
23906 }
23907 {
23908 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
23909 }
23910 {
23911 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
23912 }
23913 {
23914 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
23915 }
23916 {
23917 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
23918 }
23919 {
23920 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
23921 }
23922 {
23923 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
23924 }
23925 {
23926 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
23927 }
23928 {
23929 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
23930 }
23931 {
23932 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
23933 }
23934 {
23935 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
23936 }
23937 {
23938 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
23939 }
23940 {
23941 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
23942 }
23943 {
23944 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
23945 }
23946 {
23947 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
23948 }
23949 {
23950 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
23951 }
23952 {
23953 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
23954 }
23955 {
23956 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
23957 }
23958 {
23959 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
23960 }
23961 {
23962 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
23963 }
23964 {
23965 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
23966 }
23967 {
23968 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
23969 }
23970 {
23971 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
23972 }
23973 {
23974 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
23975 }
23976 {
23977 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
23978 }
23979 {
23980 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
23981 }
23982 {
23983 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
23984 }
23985 {
23986 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
23987 }
23988 {
23989 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
23990 }
23991 {
23992 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
23993 }
23994 {
23995 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
23996 }
23997 {
23998 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
23999 }
24000 {
24001 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
24002 }
24003 {
24004 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
24005 }
24006 {
24007 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
24008 }
24009 {
24010 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
24011 }
24012 {
24013 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
24014 }
24015 {
24016 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
24017 }
24018 {
24019 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
24020 }
24021 {
24022 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
24023 }
24024 {
24025 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
24026 }
24027 {
24028 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
24029 }
24030 {
24031 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
24032 }
24033 {
24034 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
24035 }
24036 {
24037 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
24038 }
24039 {
24040 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
24041 }
24042 {
24043 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
24044 }
24045 {
24046 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
24047 }
24048 {
24049 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
24050 }
24051 {
24052 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
24053 }
24054 {
24055 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
24056 }
24057 {
24058 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
24059 }
24060 {
24061 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
24062 }
24063 {
24064 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
24065 }
24066 {
24067 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
24068 }
24069 {
24070 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
24071 }
24072 {
24073 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
24074 }
24075 {
24076 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
24077 }
24078 {
24079 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
24080 }
24081 {
24082 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
24083 }
24084 {
24085 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
24086 }
24087 {
24088 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
24089 }
24090 {
24091 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
24092 }
24093 {
24094 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
24095 }
24096 {
24097 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
24098 }
24099 {
24100 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
24101 }
24102 {
24103 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
24104 }
24105 {
24106 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
24107 }
24108 {
24109 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
24110 }
24111 {
24112 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
24113 }
24114 {
24115 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
24116 }
24117 {
24118 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
24119 }
24120 {
24121 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
24122 }
24123 {
24124 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
24125 }
24126 {
24127 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
24128 }
24129 {
24130 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
24131 }
24132 {
24133 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
24134 }
24135 {
24136 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
24137 }
24138 {
24139 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
24140 }
24141 {
24142 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
24143 }
24144 {
24145 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
24146 }
24147 {
24148 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
24149 }
24150 {
24151 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
24152 }
24153 {
24154 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
24155 }
24156 {
24157 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
24158 }
24159 {
24160 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
24161 }
24162 {
24163 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
24164 }
24165 {
24166 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
24167 }
24168 {
24169 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
24170 }
24171 {
24172 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
24173 }
24174 {
24175 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
24176 }
24177 {
24178 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
24179 }
24180 {
24181 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
24182 }
24183 {
24184 PyDict_SetItemString(d,"BUFFER_VIRTUAL_AREA", SWIG_From_int((int)(wxBUFFER_VIRTUAL_AREA)));
24185 }
24186 {
24187 PyDict_SetItemString(d,"BUFFER_CLIENT_AREA", SWIG_From_int((int)(wxBUFFER_CLIENT_AREA)));
24188 }
24189 {
24190 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
24191 }
24192 {
24193 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
24194 }
24195 {
24196 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
24197 }
24198 {
24199 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
24200 }
24201 {
24202 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
24203 }
24204 {
24205 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
24206 }
24207 {
24208 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
24209 }
24210 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
24211 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
24212 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
24213 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
24214 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
24215 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
24216 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
24217 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
24218 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
24219 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
24220 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
24221 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
24222 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
24223 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
24224 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
24225 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
24226 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
24227 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
24228 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
24229 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
24230 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
24231 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
24232 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
24233 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
24234 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
24235 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
24236 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
24237 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
24238 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
24239 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
24240 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
24241 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
24242 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
24243 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
24244 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
24245 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
24246 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
24247 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
24248 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
24249 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
24250 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
24251 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
24252 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
24253 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
24254 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
24255 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
24256 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
24257 {
24258 PyDict_SetItemString(d,"CONTROL_DISABLED", SWIG_From_int((int)(wxCONTROL_DISABLED)));
24259 }
24260 {
24261 PyDict_SetItemString(d,"CONTROL_FOCUSED", SWIG_From_int((int)(wxCONTROL_FOCUSED)));
24262 }
24263 {
24264 PyDict_SetItemString(d,"CONTROL_PRESSED", SWIG_From_int((int)(wxCONTROL_PRESSED)));
24265 }
24266 {
24267 PyDict_SetItemString(d,"CONTROL_ISDEFAULT", SWIG_From_int((int)(wxCONTROL_ISDEFAULT)));
24268 }
24269 {
24270 PyDict_SetItemString(d,"CONTROL_ISSUBMENU", SWIG_From_int((int)(wxCONTROL_ISSUBMENU)));
24271 }
24272 {
24273 PyDict_SetItemString(d,"CONTROL_EXPANDED", SWIG_From_int((int)(wxCONTROL_EXPANDED)));
24274 }
24275 {
24276 PyDict_SetItemString(d,"CONTROL_CURRENT", SWIG_From_int((int)(wxCONTROL_CURRENT)));
24277 }
24278 {
24279 PyDict_SetItemString(d,"CONTROL_SELECTED", SWIG_From_int((int)(wxCONTROL_SELECTED)));
24280 }
24281 {
24282 PyDict_SetItemString(d,"CONTROL_CHECKED", SWIG_From_int((int)(wxCONTROL_CHECKED)));
24283 }
24284 {
24285 PyDict_SetItemString(d,"CONTROL_CHECKABLE", SWIG_From_int((int)(wxCONTROL_CHECKABLE)));
24286 }
24287 {
24288 PyDict_SetItemString(d,"CONTROL_UNDETERMINED", SWIG_From_int((int)(wxCONTROL_UNDETERMINED)));
24289 }
24290 {
24291 PyDict_SetItemString(d,"CONTROL_FLAGS_MASK", SWIG_From_int((int)(wxCONTROL_FLAGS_MASK)));
24292 }
24293 {
24294 PyDict_SetItemString(d,"CONTROL_DIRTY", SWIG_From_int((int)(wxCONTROL_DIRTY)));
24295 }
24296 {
24297 PyDict_SetItemString(d,"RendererVersion_Current_Version", SWIG_From_int((int)(wxRendererVersion::Current_Version)));
24298 }
24299 {
24300 PyDict_SetItemString(d,"RendererVersion_Current_Age", SWIG_From_int((int)(wxRendererVersion::Current_Age)));
24301 }
24302
24303 // Work around a chicken/egg problem in drawlist.cpp
24304 wxPyDrawList_SetAPIPtr();
24305
24306 }
24307
wxWidgets (Impactor)