]> 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
More updates from Morgan Hua
[wxWidgets.git] / wxPython / src / mac / _gdi_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxPostScriptDC swig_types[0]
1343 #define SWIGTYPE_p_wxBrush swig_types[1]
1344 #define SWIGTYPE_p_wxColour swig_types[2]
1345 #define SWIGTYPE_p_wxDC swig_types[3]
1346 #define SWIGTYPE_p_wxMirrorDC swig_types[4]
1347 #define SWIGTYPE_p_form_ops_t swig_types[5]
1348 #define SWIGTYPE_p_wxDuplexMode swig_types[6]
1349 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[7]
1350 #define SWIGTYPE_p_char swig_types[8]
1351 #define SWIGTYPE_p_wxIconLocation swig_types[9]
1352 #define SWIGTYPE_p_wxImage swig_types[10]
1353 #define SWIGTYPE_p_wxMetaFileDC swig_types[11]
1354 #define SWIGTYPE_p_wxMask swig_types[12]
1355 #define SWIGTYPE_p_wxSize swig_types[13]
1356 #define SWIGTYPE_p_wxFont swig_types[14]
1357 #define SWIGTYPE_p_wxWindow swig_types[15]
1358 #define SWIGTYPE_p_double swig_types[16]
1359 #define SWIGTYPE_p_wxMemoryDC swig_types[17]
1360 #define SWIGTYPE_p_wxFontMapper swig_types[18]
1361 #define SWIGTYPE_p_wxEffects swig_types[19]
1362 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[20]
1363 #define SWIGTYPE_p_wxPalette swig_types[21]
1364 #define SWIGTYPE_p_wxBitmap swig_types[22]
1365 #define SWIGTYPE_p_wxObject swig_types[23]
1366 #define SWIGTYPE_p_wxRegionIterator swig_types[24]
1367 #define SWIGTYPE_p_wxRect swig_types[25]
1368 #define SWIGTYPE_p_wxPaperSize swig_types[26]
1369 #define SWIGTYPE_p_wxString swig_types[27]
1370 #define SWIGTYPE_unsigned_int swig_types[28]
1371 #define SWIGTYPE_p_unsigned_int swig_types[29]
1372 #define SWIGTYPE_p_wxPrinterDC swig_types[30]
1373 #define SWIGTYPE_p_wxIconBundle swig_types[31]
1374 #define SWIGTYPE_p_wxPoint swig_types[32]
1375 #define SWIGTYPE_p_wxDash swig_types[33]
1376 #define SWIGTYPE_p_wxScreenDC swig_types[34]
1377 #define SWIGTYPE_p_wxCursor swig_types[35]
1378 #define SWIGTYPE_p_wxClientDC swig_types[36]
1379 #define SWIGTYPE_p_wxBufferedDC swig_types[37]
1380 #define SWIGTYPE_p_wxImageList swig_types[38]
1381 #define SWIGTYPE_p_unsigned_char swig_types[39]
1382 #define SWIGTYPE_p_wxGDIObject swig_types[40]
1383 #define SWIGTYPE_p_wxIcon swig_types[41]
1384 #define SWIGTYPE_p_wxLocale swig_types[42]
1385 #define SWIGTYPE_ptrdiff_t swig_types[43]
1386 #define SWIGTYPE_std__ptrdiff_t swig_types[44]
1387 #define SWIGTYPE_p_wxRegion swig_types[45]
1388 #define SWIGTYPE_p_wxConfigBase swig_types[46]
1389 #define SWIGTYPE_p_wxLanguageInfo swig_types[47]
1390 #define SWIGTYPE_p_wxWindowDC swig_types[48]
1391 #define SWIGTYPE_p_wxPrintData swig_types[49]
1392 #define SWIGTYPE_p_wxBrushList swig_types[50]
1393 #define SWIGTYPE_p_wxFontList swig_types[51]
1394 #define SWIGTYPE_p_wxPen swig_types[52]
1395 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[53]
1396 #define SWIGTYPE_p_wxPaintDC swig_types[54]
1397 #define SWIGTYPE_p_wxPenList swig_types[55]
1398 #define SWIGTYPE_p_int swig_types[56]
1399 #define SWIGTYPE_p_wxMetaFile swig_types[57]
1400 #define SWIGTYPE_p_unsigned_long swig_types[58]
1401 #define SWIGTYPE_p_wxNativeFontInfo swig_types[59]
1402 #define SWIGTYPE_p_wxEncodingConverter swig_types[60]
1403 #define SWIGTYPE_p_wxColourDatabase swig_types[61]
1404 static swig_type_info *swig_types[63];
1405
1406 /* -------- TYPES TABLE (END) -------- */
1407
1408
1409 /*-----------------------------------------------
1410 @(target):= _gdi_.so
1411 ------------------------------------------------*/
1412 #define SWIG_init init_gdi_
1413
1414 #define SWIG_name "_gdi_"
1415
1416 #include "wx/wxPython/wxPython.h"
1417 #include "wx/wxPython/pyclasses.h"
1418
1419
1420 static const wxString wxPyEmptyString(wxEmptyString);
1421
1422 #include <limits.h>
1423
1424
1425 SWIGINTERN int
1426 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1427 const char *errmsg)
1428 {
1429 if (value < min_value) {
1430 if (errmsg) {
1431 PyErr_Format(PyExc_OverflowError,
1432 "value %ld is less than '%s' minimum %ld",
1433 value, errmsg, min_value);
1434 }
1435 return 0;
1436 } else if (value > max_value) {
1437 if (errmsg) {
1438 PyErr_Format(PyExc_OverflowError,
1439 "value %ld is greater than '%s' maximum %ld",
1440 value, errmsg, max_value);
1441 }
1442 return 0;
1443 }
1444 return 1;
1445 }
1446
1447
1448 SWIGINTERN int
1449 SWIG_AsVal_long(PyObject* obj, long* val)
1450 {
1451 if (PyNumber_Check(obj)) {
1452 if (val) *val = PyInt_AsLong(obj);
1453 return 1;
1454 }
1455 else {
1456 SWIG_type_error("number", obj);
1457 }
1458 return 0;
1459 }
1460
1461
1462 #if INT_MAX != LONG_MAX
1463 SWIGINTERN int
1464 SWIG_AsVal_int(PyObject *obj, int *val)
1465 {
1466 const char* errmsg = val ? "int" : (char*)0;
1467 long v;
1468 if (SWIG_AsVal_long(obj, &v)) {
1469 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1470 if (val) *val = (int)(v);
1471 return 1;
1472 } else {
1473 return 0;
1474 }
1475 } else {
1476 PyErr_Clear();
1477 }
1478 if (val) {
1479 SWIG_type_error(errmsg, obj);
1480 }
1481 return 0;
1482 }
1483 #else
1484 SWIGINTERNSHORT int
1485 SWIG_AsVal_int(PyObject *obj, int *val)
1486 {
1487 return SWIG_AsVal_long(obj,(long*)val);
1488 }
1489 #endif
1490
1491
1492 SWIGINTERN int
1493 SWIG_AsVal_bool(PyObject *obj, bool *val)
1494 {
1495 if (obj == Py_True) {
1496 if (val) *val = true;
1497 return 1;
1498 }
1499 if (obj == Py_False) {
1500 if (val) *val = false;
1501 return 1;
1502 }
1503 int res = 0;
1504 if (SWIG_AsVal_int(obj, &res)) {
1505 if (val) *val = res ? true : false;
1506 return 1;
1507 } else {
1508 PyErr_Clear();
1509 }
1510 if (val) {
1511 SWIG_type_error("bool", obj);
1512 }
1513 return 0;
1514 }
1515
1516
1517 SWIGINTERNSHORT bool
1518 SWIG_As_bool(PyObject* obj)
1519 {
1520 bool v;
1521 if (!SWIG_AsVal_bool(obj, &v)) {
1522 /*
1523 this is needed to make valgrind/purify happier.
1524 */
1525 memset((void*)&v, 0, sizeof(bool));
1526 }
1527 return v;
1528 }
1529
1530
1531 SWIGINTERNSHORT int
1532 SWIG_Check_bool(PyObject* obj)
1533 {
1534 return SWIG_AsVal_bool(obj, (bool*)0);
1535 }
1536
1537
1538 SWIGINTERN int
1539 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1540 {
1541 long v = 0;
1542 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1543 SWIG_type_error("unsigned number", obj);
1544 }
1545 else if (val)
1546 *val = (unsigned long)v;
1547 return 1;
1548 }
1549
1550
1551 SWIGINTERNSHORT int
1552 SWIG_CheckUnsignedLongInRange(unsigned long value,
1553 unsigned long max_value,
1554 const char *errmsg)
1555 {
1556 if (value > max_value) {
1557 if (errmsg) {
1558 PyErr_Format(PyExc_OverflowError,
1559 "value %lu is greater than '%s' minimum %lu",
1560 value, errmsg, max_value);
1561 }
1562 return 0;
1563 }
1564 return 1;
1565 }
1566
1567
1568 SWIGINTERN int
1569 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1570 {
1571 const char* errmsg = val ? "unsigned char" : (char*)0;
1572 unsigned long v;
1573 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1574 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1575 if (val) *val = (unsigned char)(v);
1576 return 1;
1577 } else {
1578 return 0;
1579 }
1580 } else {
1581 PyErr_Clear();
1582 }
1583 if (val) {
1584 SWIG_type_error(errmsg, obj);
1585 }
1586 return 0;
1587 }
1588
1589
1590 SWIGINTERNSHORT unsigned char
1591 SWIG_As_unsigned_SS_char(PyObject* obj)
1592 {
1593 unsigned char v;
1594 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1595 /*
1596 this is needed to make valgrind/purify happier.
1597 */
1598 memset((void*)&v, 0, sizeof(unsigned char));
1599 }
1600 return v;
1601 }
1602
1603
1604 SWIGINTERNSHORT int
1605 SWIG_Check_unsigned_SS_char(PyObject* obj)
1606 {
1607 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1608 }
1609
1610
1611 SWIGINTERNSHORT unsigned long
1612 SWIG_As_unsigned_SS_long(PyObject* obj)
1613 {
1614 unsigned long v;
1615 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1616 /*
1617 this is needed to make valgrind/purify happier.
1618 */
1619 memset((void*)&v, 0, sizeof(unsigned long));
1620 }
1621 return v;
1622 }
1623
1624
1625 SWIGINTERNSHORT int
1626 SWIG_Check_unsigned_SS_long(PyObject* obj)
1627 {
1628 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1629 }
1630
1631
1632 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1633 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1634 /*@@*/
1635
1636
1637 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1638 #define SWIG_From_long PyInt_FromLong
1639 /*@@*/
1640
1641 static PyObject *wxColour_Get(wxColour *self){
1642 PyObject* rv = PyTuple_New(3);
1643 int red = -1;
1644 int green = -1;
1645 int blue = -1;
1646 if (self->Ok()) {
1647 red = self->Red();
1648 green = self->Green();
1649 blue = self->Blue();
1650 }
1651 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1652 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1653 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1654 return rv;
1655 }
1656 static unsigned long wxColour_GetRGB(wxColour *self){
1657 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1658 }
1659
1660 SWIGINTERNSHORT PyObject*
1661 SWIG_From_unsigned_SS_long(unsigned long value)
1662 {
1663 return (value > LONG_MAX) ?
1664 PyLong_FromUnsignedLong(value)
1665 : PyInt_FromLong((long)(value));
1666 }
1667
1668
1669 SWIGINTERNSHORT int
1670 SWIG_As_int(PyObject* obj)
1671 {
1672 int v;
1673 if (!SWIG_AsVal_int(obj, &v)) {
1674 /*
1675 this is needed to make valgrind/purify happier.
1676 */
1677 memset((void*)&v, 0, sizeof(int));
1678 }
1679 return v;
1680 }
1681
1682
1683 SWIGINTERNSHORT int
1684 SWIG_Check_int(PyObject* obj)
1685 {
1686 return SWIG_AsVal_int(obj, (int*)0);
1687 }
1688
1689
1690 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1691 #define SWIG_From_int PyInt_FromLong
1692 /*@@*/
1693
1694
1695 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1696 PyObject* o2;
1697 PyObject* o3;
1698
1699 if (!target) {
1700 target = o;
1701 } else if (target == Py_None) {
1702 Py_DECREF(Py_None);
1703 target = o;
1704 } else {
1705 if (!PyTuple_Check(target)) {
1706 o2 = target;
1707 target = PyTuple_New(1);
1708 PyTuple_SetItem(target, 0, o2);
1709 }
1710 o3 = PyTuple_New(1);
1711 PyTuple_SetItem(o3, 0, o);
1712
1713 o2 = target;
1714 target = PySequence_Concat(o2, o3);
1715 Py_DECREF(o2);
1716 Py_DECREF(o3);
1717 }
1718 return target;
1719 }
1720
1721
1722 static PyObject *wxPen_GetDashes(wxPen *self){
1723 wxDash* dashes;
1724 int count = self->GetDashes(&dashes);
1725 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1726 PyObject* retval = PyList_New(0);
1727 for (int x=0; x<count; x++) {
1728 PyObject* pyint = PyInt_FromLong(dashes[x]);
1729 PyList_Append(retval, pyint);
1730 Py_DECREF(pyint);
1731 }
1732 wxPyEndBlockThreads(blocked);
1733 return retval;
1734 }
1735 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1736 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1737 int size = PyList_Size(pyDashes);
1738 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1739
1740 // black magic warning! The array of wxDashes needs to exist as
1741 // long as the pen does because wxPen does not copy the array. So
1742 // stick a copy in a Python string object and attach it to _self,
1743 // and then call SetDashes with a pointer to that array. Then
1744 // when the Python pen object is destroyed the array will be
1745 // cleaned up too.
1746 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1747 PyObject_SetAttrString(_self, "_dashes", strDashes);
1748
1749 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1750 delete [] dashes;
1751 Py_DECREF(strDashes);
1752 wxPyEndBlockThreads(blocked);
1753 }
1754 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1755 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1756
1757 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1758 #define SWIG_From_short PyInt_FromLong
1759 /*@@*/
1760
1761
1762 SWIGINTERN int
1763 SWIG_AsVal_short(PyObject *obj, short *val)
1764 {
1765 const char* errmsg = val ? "short" : (char*)0;
1766 long v;
1767 if (SWIG_AsVal_long(obj, &v)) {
1768 if (SWIG_CheckLongInRange(v, SHRT_MIN, SHRT_MAX, errmsg)) {
1769 if (val) *val = (short)(v);
1770 return 1;
1771 } else {
1772 return 0;
1773 }
1774 } else {
1775 PyErr_Clear();
1776 }
1777 if (val) {
1778 SWIG_type_error(errmsg, obj);
1779 }
1780 return 0;
1781 }
1782
1783
1784 SWIGINTERNSHORT short
1785 SWIG_As_short(PyObject* obj)
1786 {
1787 short v;
1788 if (!SWIG_AsVal_short(obj, &v)) {
1789 /*
1790 this is needed to make valgrind/purify happier.
1791 */
1792 memset((void*)&v, 0, sizeof(short));
1793 }
1794 return v;
1795 }
1796
1797
1798 SWIGINTERNSHORT int
1799 SWIG_Check_short(PyObject* obj)
1800 {
1801 return SWIG_AsVal_short(obj, (short*)0);
1802 }
1803
1804
1805 #include <wx/image.h>
1806
1807 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1808 char** cArray = NULL;
1809 int count;
1810
1811 if (!PyList_Check(listOfStrings)) {
1812 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1813 return NULL;
1814 }
1815 count = PyList_Size(listOfStrings);
1816 cArray = new char*[count];
1817
1818 for(int x=0; x<count; x++) {
1819 // TODO: Need some validation and error checking here
1820 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1821 }
1822 return cArray;
1823 }
1824
1825
1826 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1827 char** cArray = NULL;
1828 wxBitmap* bmp;
1829
1830 cArray = ConvertListOfStrings(listOfStrings);
1831 if (! cArray)
1832 return NULL;
1833 bmp = new wxBitmap(cArray);
1834 delete [] cArray;
1835 return bmp;
1836 }
1837 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1838 char* buf;
1839 int length;
1840 PyString_AsStringAndSize(bits, &buf, &length);
1841 return new wxBitmap(buf, width, height, depth);
1842 }
1843 static wxSize wxBitmap_GetSize(wxBitmap *self){
1844 wxSize size(self->GetWidth(), self->GetHeight());
1845 return size;
1846 }
1847 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1848 wxMask *mask = new wxMask(*self, colour);
1849 self->SetMask(mask);
1850 }
1851 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1852 self->SetWidth(size.x);
1853 self->SetHeight(size.y);
1854 }
1855 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1856 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1857 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1858 if ( !colour.Ok() )
1859 return new wxMask(bitmap, *wxBLACK);
1860 else
1861 return new wxMask(bitmap, colour);
1862 }
1863
1864 #include <wx/iconbndl.h>
1865
1866 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1867 wxIcon* icon = new wxIcon();
1868 icon->CopyFromBitmap(bmp);
1869 return icon;
1870 }
1871 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1872 char** cArray = NULL;
1873 wxIcon* icon;
1874
1875 cArray = ConvertListOfStrings(listOfStrings);
1876 if (! cArray)
1877 return NULL;
1878 icon = new wxIcon(cArray);
1879 delete [] cArray;
1880 return icon;
1881 }
1882 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1883
1884
1885
1886 return new wxIconLocation(*filename);
1887
1888 }
1889 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1890
1891
1892
1893 // do nothing
1894
1895 }
1896 static int wxIconLocation_GetIndex(wxIconLocation *self){
1897
1898
1899
1900 return -1;
1901
1902 }
1903
1904 SWIGINTERNSHORT long
1905 SWIG_As_long(PyObject* obj)
1906 {
1907 long v;
1908 if (!SWIG_AsVal_long(obj, &v)) {
1909 /*
1910 this is needed to make valgrind/purify happier.
1911 */
1912 memset((void*)&v, 0, sizeof(long));
1913 }
1914 return v;
1915 }
1916
1917
1918 SWIGINTERNSHORT int
1919 SWIG_Check_long(PyObject* obj)
1920 {
1921 return SWIG_AsVal_long(obj, (long*)0);
1922 }
1923
1924 static wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1925 #ifdef __WXGTK__
1926 wxImage img(cursorName, type);
1927 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
1928 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
1929 return new wxCursor(img);
1930 #else
1931 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
1932 #endif
1933 }
1934
1935
1936 static void wxRegionIterator_Next(wxRegionIterator *self){
1937 (*self) ++;
1938 }
1939 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1940 return self->operator bool();
1941 }
1942
1943 #include <wx/fontutil.h>
1944 #include <wx/fontmap.h>
1945 #include <wx/fontenum.h>
1946
1947 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1948 return self->ToString();
1949 }
1950
1951 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
1952 static wxNativeEncodingInfo info;
1953 if ( wxGetNativeFontEncoding(encoding, &info) )
1954 return &info;
1955 else
1956 return NULL;
1957 }
1958
1959 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1960 wxFontEncoding alt_enc;
1961 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1962 return PyInt_FromLong(alt_enc);
1963 else {
1964 Py_INCREF(Py_None);
1965 return Py_None;
1966 }
1967 }
1968 static wxFont *new_wxFont(wxString const &info){
1969 wxNativeFontInfo nfi;
1970 nfi.FromString(info);
1971 return new wxFont(nfi);
1972 }
1973 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1974 return wxFont::New(pointSize, family, flags, face, encoding);
1975 }
1976 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1977 return wxFontBase::New(pixelSize, family,
1978 style, weight, underlined,
1979 face, encoding);
1980 }
1981 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1982 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1983
1984 class wxPyFontEnumerator : public wxFontEnumerator {
1985 public:
1986 wxPyFontEnumerator() {}
1987 ~wxPyFontEnumerator() {}
1988
1989 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1990 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1991
1992 PYPRIVATE;
1993 };
1994
1995 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
1996 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
1997
1998
1999 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
2000 wxArrayString* arr = self->GetEncodings();
2001 if (arr)
2002 return wxArrayString2PyList_helper(*arr);
2003 else
2004 return PyList_New(0);
2005 }
2006 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
2007 wxArrayString* arr = self->GetFacenames();
2008 if (arr)
2009 return wxArrayString2PyList_helper(*arr);
2010 else
2011 return PyList_New(0);
2012 }
2013
2014 #include <locale.h>
2015
2016 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
2017 wxLocale* loc;
2018 if (language == -1)
2019 loc = new wxLocale();
2020 else
2021 loc = new wxLocale(language, flags);
2022 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2023 // for the floating point conversions and such to work right.
2024 #if PY_VERSION_HEX < 0x02040000
2025 setlocale(LC_NUMERIC, "C");
2026 #endif
2027 return loc;
2028 }
2029 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
2030 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
2031 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2032 // for the floating point conversions and such to work right.
2033 #if PY_VERSION_HEX < 0x02040000
2034 setlocale(LC_NUMERIC, "C");
2035 #endif
2036 return rc;
2037 }
2038 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
2039 bool rc = self->Init(language, flags);
2040 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2041 // for the floating point conversions and such to work right.
2042 #if PY_VERSION_HEX < 0x02040000
2043 setlocale(LC_NUMERIC, "C");
2044 #endif
2045 return rc;
2046 }
2047
2048 #include "wx/wxPython/pydrawxxx.h"
2049
2050 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2051 wxColour col;
2052 self->GetPixel(x, y, &col);
2053 return col;
2054 }
2055 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2056 wxColour col;
2057 self->GetPixel(pt, &col);
2058 return col;
2059 }
2060
2061 SWIGINTERN int
2062 SWIG_AsVal_double(PyObject *obj, double* val)
2063 {
2064 if (PyNumber_Check(obj)) {
2065 if (val) *val = PyFloat_AsDouble(obj);
2066 return 1;
2067 }
2068 else {
2069 SWIG_type_error("number", obj);
2070 }
2071 return 0;
2072 }
2073
2074
2075 SWIGINTERNSHORT double
2076 SWIG_As_double(PyObject* obj)
2077 {
2078 double v;
2079 if (!SWIG_AsVal_double(obj, &v)) {
2080 /*
2081 this is needed to make valgrind/purify happier.
2082 */
2083 memset((void*)&v, 0, sizeof(double));
2084 }
2085 return v;
2086 }
2087
2088
2089 SWIGINTERNSHORT int
2090 SWIG_Check_double(PyObject* obj)
2091 {
2092 return SWIG_AsVal_double(obj, (double*)0);
2093 }
2094
2095 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2096 wxRect rv;
2097 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2098 return rv;
2099 }
2100
2101 static wxRect wxDC_GetClippingRect(wxDC *self){
2102 wxRect rect;
2103 self->GetClippingBox(rect);
2104 return rect;
2105 }
2106 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2107 wxArrayInt widths;
2108 self->GetPartialTextExtents(text, widths);
2109 return widths;
2110 }
2111
2112 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2113 #define SWIG_From_double PyFloat_FromDouble
2114 /*@@*/
2115
2116
2117 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2118 self->SetLogicalOrigin(point.x, point.y);
2119 }
2120 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2121 self->SetDeviceOrigin(point.x, point.y);
2122 }
2123 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2124 self->CalcBoundingBox(point.x, point.y);
2125 }
2126 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2127 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2128 }
2129 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2130 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2131 }
2132 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2133 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2134 }
2135 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2136 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2137 }
2138 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2139 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2140 }
2141 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2142 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2143 }
2144
2145 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2146 *x1 = dc->MinX();
2147 *y1 = dc->MinY();
2148 *x2 = dc->MaxX();
2149 *y2 = dc->MaxY();
2150 }
2151
2152
2153 #include <wx/dcbuffer.h>
2154
2155
2156 #include <wx/dcps.h>
2157
2158
2159 #include <wx/metafile.h>
2160
2161
2162
2163 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2164 self->AddColour(name, wxColour(red, green, blue));
2165 }
2166
2167 #include <wx/effects.h>
2168
2169 #ifdef __cplusplus
2170 extern "C" {
2171 #endif
2172 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2173 PyObject *resultobj;
2174 wxGDIObject *result;
2175 char *kwnames[] = {
2176 NULL
2177 };
2178
2179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2180 {
2181 if (!wxPyCheckForApp()) SWIG_fail;
2182 PyThreadState* __tstate = wxPyBeginAllowThreads();
2183 result = (wxGDIObject *)new wxGDIObject();
2184
2185 wxPyEndAllowThreads(__tstate);
2186 if (PyErr_Occurred()) SWIG_fail;
2187 }
2188 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2189 return resultobj;
2190 fail:
2191 return NULL;
2192 }
2193
2194
2195 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2196 PyObject *resultobj;
2197 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2198 PyObject * obj0 = 0 ;
2199 char *kwnames[] = {
2200 (char *) "self", NULL
2201 };
2202
2203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2205 if (SWIG_arg_fail(1)) SWIG_fail;
2206 {
2207 PyThreadState* __tstate = wxPyBeginAllowThreads();
2208 delete arg1;
2209
2210 wxPyEndAllowThreads(__tstate);
2211 if (PyErr_Occurred()) SWIG_fail;
2212 }
2213 Py_INCREF(Py_None); resultobj = Py_None;
2214 return resultobj;
2215 fail:
2216 return NULL;
2217 }
2218
2219
2220 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2221 PyObject *resultobj;
2222 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2223 bool result;
2224 PyObject * obj0 = 0 ;
2225 char *kwnames[] = {
2226 (char *) "self", NULL
2227 };
2228
2229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2231 if (SWIG_arg_fail(1)) SWIG_fail;
2232 {
2233 PyThreadState* __tstate = wxPyBeginAllowThreads();
2234 result = (bool)(arg1)->GetVisible();
2235
2236 wxPyEndAllowThreads(__tstate);
2237 if (PyErr_Occurred()) SWIG_fail;
2238 }
2239 {
2240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2241 }
2242 return resultobj;
2243 fail:
2244 return NULL;
2245 }
2246
2247
2248 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2249 PyObject *resultobj;
2250 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2251 bool arg2 ;
2252 PyObject * obj0 = 0 ;
2253 PyObject * obj1 = 0 ;
2254 char *kwnames[] = {
2255 (char *) "self",(char *) "visible", NULL
2256 };
2257
2258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2260 if (SWIG_arg_fail(1)) SWIG_fail;
2261 {
2262 arg2 = (bool)(SWIG_As_bool(obj1));
2263 if (SWIG_arg_fail(2)) SWIG_fail;
2264 }
2265 {
2266 PyThreadState* __tstate = wxPyBeginAllowThreads();
2267 (arg1)->SetVisible(arg2);
2268
2269 wxPyEndAllowThreads(__tstate);
2270 if (PyErr_Occurred()) SWIG_fail;
2271 }
2272 Py_INCREF(Py_None); resultobj = Py_None;
2273 return resultobj;
2274 fail:
2275 return NULL;
2276 }
2277
2278
2279 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2280 PyObject *resultobj;
2281 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2282 bool result;
2283 PyObject * obj0 = 0 ;
2284 char *kwnames[] = {
2285 (char *) "self", NULL
2286 };
2287
2288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2290 if (SWIG_arg_fail(1)) SWIG_fail;
2291 {
2292 PyThreadState* __tstate = wxPyBeginAllowThreads();
2293 result = (bool)(arg1)->IsNull();
2294
2295 wxPyEndAllowThreads(__tstate);
2296 if (PyErr_Occurred()) SWIG_fail;
2297 }
2298 {
2299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2300 }
2301 return resultobj;
2302 fail:
2303 return NULL;
2304 }
2305
2306
2307 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2308 PyObject *obj;
2309 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2310 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2311 Py_INCREF(obj);
2312 return Py_BuildValue((char *)"");
2313 }
2314 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2315 PyObject *resultobj;
2316 byte arg1 = (byte) 0 ;
2317 byte arg2 = (byte) 0 ;
2318 byte arg3 = (byte) 0 ;
2319 wxColour *result;
2320 PyObject * obj0 = 0 ;
2321 PyObject * obj1 = 0 ;
2322 PyObject * obj2 = 0 ;
2323 char *kwnames[] = {
2324 (char *) "red",(char *) "green",(char *) "blue", NULL
2325 };
2326
2327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2328 if (obj0) {
2329 {
2330 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2331 if (SWIG_arg_fail(1)) SWIG_fail;
2332 }
2333 }
2334 if (obj1) {
2335 {
2336 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2337 if (SWIG_arg_fail(2)) SWIG_fail;
2338 }
2339 }
2340 if (obj2) {
2341 {
2342 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2343 if (SWIG_arg_fail(3)) SWIG_fail;
2344 }
2345 }
2346 {
2347 PyThreadState* __tstate = wxPyBeginAllowThreads();
2348 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2349
2350 wxPyEndAllowThreads(__tstate);
2351 if (PyErr_Occurred()) SWIG_fail;
2352 }
2353 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2354 return resultobj;
2355 fail:
2356 return NULL;
2357 }
2358
2359
2360 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2361 PyObject *resultobj;
2362 wxString *arg1 = 0 ;
2363 wxColour *result;
2364 bool temp1 = false ;
2365 PyObject * obj0 = 0 ;
2366 char *kwnames[] = {
2367 (char *) "colorName", NULL
2368 };
2369
2370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2371 {
2372 arg1 = wxString_in_helper(obj0);
2373 if (arg1 == NULL) SWIG_fail;
2374 temp1 = true;
2375 }
2376 {
2377 if (!wxPyCheckForApp()) SWIG_fail;
2378 PyThreadState* __tstate = wxPyBeginAllowThreads();
2379 result = (wxColour *)new wxColour((wxString const &)*arg1);
2380
2381 wxPyEndAllowThreads(__tstate);
2382 if (PyErr_Occurred()) SWIG_fail;
2383 }
2384 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2385 {
2386 if (temp1)
2387 delete arg1;
2388 }
2389 return resultobj;
2390 fail:
2391 {
2392 if (temp1)
2393 delete arg1;
2394 }
2395 return NULL;
2396 }
2397
2398
2399 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2400 PyObject *resultobj;
2401 unsigned long arg1 ;
2402 wxColour *result;
2403 PyObject * obj0 = 0 ;
2404 char *kwnames[] = {
2405 (char *) "colRGB", NULL
2406 };
2407
2408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2409 {
2410 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2411 if (SWIG_arg_fail(1)) SWIG_fail;
2412 }
2413 {
2414 PyThreadState* __tstate = wxPyBeginAllowThreads();
2415 result = (wxColour *)new wxColour(arg1);
2416
2417 wxPyEndAllowThreads(__tstate);
2418 if (PyErr_Occurred()) SWIG_fail;
2419 }
2420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2421 return resultobj;
2422 fail:
2423 return NULL;
2424 }
2425
2426
2427 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2428 PyObject *resultobj;
2429 wxColour *arg1 = (wxColour *) 0 ;
2430 PyObject * obj0 = 0 ;
2431 char *kwnames[] = {
2432 (char *) "self", NULL
2433 };
2434
2435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2437 if (SWIG_arg_fail(1)) SWIG_fail;
2438 {
2439 PyThreadState* __tstate = wxPyBeginAllowThreads();
2440 delete arg1;
2441
2442 wxPyEndAllowThreads(__tstate);
2443 if (PyErr_Occurred()) SWIG_fail;
2444 }
2445 Py_INCREF(Py_None); resultobj = Py_None;
2446 return resultobj;
2447 fail:
2448 return NULL;
2449 }
2450
2451
2452 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2453 PyObject *resultobj;
2454 wxColour *arg1 = (wxColour *) 0 ;
2455 byte result;
2456 PyObject * obj0 = 0 ;
2457 char *kwnames[] = {
2458 (char *) "self", NULL
2459 };
2460
2461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2463 if (SWIG_arg_fail(1)) SWIG_fail;
2464 {
2465 PyThreadState* __tstate = wxPyBeginAllowThreads();
2466 result = (byte)(arg1)->Red();
2467
2468 wxPyEndAllowThreads(__tstate);
2469 if (PyErr_Occurred()) SWIG_fail;
2470 }
2471 {
2472 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2473 }
2474 return resultobj;
2475 fail:
2476 return NULL;
2477 }
2478
2479
2480 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2481 PyObject *resultobj;
2482 wxColour *arg1 = (wxColour *) 0 ;
2483 byte result;
2484 PyObject * obj0 = 0 ;
2485 char *kwnames[] = {
2486 (char *) "self", NULL
2487 };
2488
2489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2491 if (SWIG_arg_fail(1)) SWIG_fail;
2492 {
2493 PyThreadState* __tstate = wxPyBeginAllowThreads();
2494 result = (byte)(arg1)->Green();
2495
2496 wxPyEndAllowThreads(__tstate);
2497 if (PyErr_Occurred()) SWIG_fail;
2498 }
2499 {
2500 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2501 }
2502 return resultobj;
2503 fail:
2504 return NULL;
2505 }
2506
2507
2508 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2509 PyObject *resultobj;
2510 wxColour *arg1 = (wxColour *) 0 ;
2511 byte result;
2512 PyObject * obj0 = 0 ;
2513 char *kwnames[] = {
2514 (char *) "self", NULL
2515 };
2516
2517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2519 if (SWIG_arg_fail(1)) SWIG_fail;
2520 {
2521 PyThreadState* __tstate = wxPyBeginAllowThreads();
2522 result = (byte)(arg1)->Blue();
2523
2524 wxPyEndAllowThreads(__tstate);
2525 if (PyErr_Occurred()) SWIG_fail;
2526 }
2527 {
2528 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2529 }
2530 return resultobj;
2531 fail:
2532 return NULL;
2533 }
2534
2535
2536 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2537 PyObject *resultobj;
2538 wxColour *arg1 = (wxColour *) 0 ;
2539 bool result;
2540 PyObject * obj0 = 0 ;
2541 char *kwnames[] = {
2542 (char *) "self", NULL
2543 };
2544
2545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2547 if (SWIG_arg_fail(1)) SWIG_fail;
2548 {
2549 PyThreadState* __tstate = wxPyBeginAllowThreads();
2550 result = (bool)(arg1)->Ok();
2551
2552 wxPyEndAllowThreads(__tstate);
2553 if (PyErr_Occurred()) SWIG_fail;
2554 }
2555 {
2556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2557 }
2558 return resultobj;
2559 fail:
2560 return NULL;
2561 }
2562
2563
2564 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2565 PyObject *resultobj;
2566 wxColour *arg1 = (wxColour *) 0 ;
2567 byte arg2 ;
2568 byte arg3 ;
2569 byte arg4 ;
2570 PyObject * obj0 = 0 ;
2571 PyObject * obj1 = 0 ;
2572 PyObject * obj2 = 0 ;
2573 PyObject * obj3 = 0 ;
2574 char *kwnames[] = {
2575 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2576 };
2577
2578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2580 if (SWIG_arg_fail(1)) SWIG_fail;
2581 {
2582 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2583 if (SWIG_arg_fail(2)) SWIG_fail;
2584 }
2585 {
2586 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2587 if (SWIG_arg_fail(3)) SWIG_fail;
2588 }
2589 {
2590 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2591 if (SWIG_arg_fail(4)) SWIG_fail;
2592 }
2593 {
2594 PyThreadState* __tstate = wxPyBeginAllowThreads();
2595 (arg1)->Set(arg2,arg3,arg4);
2596
2597 wxPyEndAllowThreads(__tstate);
2598 if (PyErr_Occurred()) SWIG_fail;
2599 }
2600 Py_INCREF(Py_None); resultobj = Py_None;
2601 return resultobj;
2602 fail:
2603 return NULL;
2604 }
2605
2606
2607 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2608 PyObject *resultobj;
2609 wxColour *arg1 = (wxColour *) 0 ;
2610 unsigned long arg2 ;
2611 PyObject * obj0 = 0 ;
2612 PyObject * obj1 = 0 ;
2613 char *kwnames[] = {
2614 (char *) "self",(char *) "colRGB", NULL
2615 };
2616
2617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2619 if (SWIG_arg_fail(1)) SWIG_fail;
2620 {
2621 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2622 if (SWIG_arg_fail(2)) SWIG_fail;
2623 }
2624 {
2625 PyThreadState* __tstate = wxPyBeginAllowThreads();
2626 (arg1)->Set(arg2);
2627
2628 wxPyEndAllowThreads(__tstate);
2629 if (PyErr_Occurred()) SWIG_fail;
2630 }
2631 Py_INCREF(Py_None); resultobj = Py_None;
2632 return resultobj;
2633 fail:
2634 return NULL;
2635 }
2636
2637
2638 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2639 PyObject *resultobj;
2640 wxColour *arg1 = (wxColour *) 0 ;
2641 wxString *arg2 = 0 ;
2642 bool temp2 = false ;
2643 PyObject * obj0 = 0 ;
2644 PyObject * obj1 = 0 ;
2645 char *kwnames[] = {
2646 (char *) "self",(char *) "colourName", NULL
2647 };
2648
2649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2651 if (SWIG_arg_fail(1)) SWIG_fail;
2652 {
2653 arg2 = wxString_in_helper(obj1);
2654 if (arg2 == NULL) SWIG_fail;
2655 temp2 = true;
2656 }
2657 {
2658 PyThreadState* __tstate = wxPyBeginAllowThreads();
2659 (arg1)->InitFromName((wxString const &)*arg2);
2660
2661 wxPyEndAllowThreads(__tstate);
2662 if (PyErr_Occurred()) SWIG_fail;
2663 }
2664 Py_INCREF(Py_None); resultobj = Py_None;
2665 {
2666 if (temp2)
2667 delete arg2;
2668 }
2669 return resultobj;
2670 fail:
2671 {
2672 if (temp2)
2673 delete arg2;
2674 }
2675 return NULL;
2676 }
2677
2678
2679 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2680 PyObject *resultobj;
2681 wxColour *arg1 = (wxColour *) 0 ;
2682 long result;
2683 PyObject * obj0 = 0 ;
2684 char *kwnames[] = {
2685 (char *) "self", NULL
2686 };
2687
2688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2690 if (SWIG_arg_fail(1)) SWIG_fail;
2691 {
2692 PyThreadState* __tstate = wxPyBeginAllowThreads();
2693 result = (long)((wxColour const *)arg1)->GetPixel();
2694
2695 wxPyEndAllowThreads(__tstate);
2696 if (PyErr_Occurred()) SWIG_fail;
2697 }
2698 {
2699 resultobj = SWIG_From_long((long)(result));
2700 }
2701 return resultobj;
2702 fail:
2703 return NULL;
2704 }
2705
2706
2707 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2708 PyObject *resultobj;
2709 wxColour *arg1 = (wxColour *) 0 ;
2710 wxColour *arg2 = 0 ;
2711 bool result;
2712 wxColour temp2 ;
2713 PyObject * obj0 = 0 ;
2714 PyObject * obj1 = 0 ;
2715 char *kwnames[] = {
2716 (char *) "self",(char *) "colour", NULL
2717 };
2718
2719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2721 if (SWIG_arg_fail(1)) SWIG_fail;
2722 {
2723 arg2 = &temp2;
2724 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2725 }
2726 {
2727 PyThreadState* __tstate = wxPyBeginAllowThreads();
2728 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2729
2730 wxPyEndAllowThreads(__tstate);
2731 if (PyErr_Occurred()) SWIG_fail;
2732 }
2733 {
2734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2735 }
2736 return resultobj;
2737 fail:
2738 return NULL;
2739 }
2740
2741
2742 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2743 PyObject *resultobj;
2744 wxColour *arg1 = (wxColour *) 0 ;
2745 wxColour *arg2 = 0 ;
2746 bool result;
2747 wxColour temp2 ;
2748 PyObject * obj0 = 0 ;
2749 PyObject * obj1 = 0 ;
2750 char *kwnames[] = {
2751 (char *) "self",(char *) "colour", NULL
2752 };
2753
2754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2756 if (SWIG_arg_fail(1)) SWIG_fail;
2757 {
2758 arg2 = &temp2;
2759 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2760 }
2761 {
2762 PyThreadState* __tstate = wxPyBeginAllowThreads();
2763 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2764
2765 wxPyEndAllowThreads(__tstate);
2766 if (PyErr_Occurred()) SWIG_fail;
2767 }
2768 {
2769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2770 }
2771 return resultobj;
2772 fail:
2773 return NULL;
2774 }
2775
2776
2777 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2778 PyObject *resultobj;
2779 wxColour *arg1 = (wxColour *) 0 ;
2780 PyObject *result;
2781 PyObject * obj0 = 0 ;
2782 char *kwnames[] = {
2783 (char *) "self", NULL
2784 };
2785
2786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2788 if (SWIG_arg_fail(1)) SWIG_fail;
2789 {
2790 PyThreadState* __tstate = wxPyBeginAllowThreads();
2791 result = (PyObject *)wxColour_Get(arg1);
2792
2793 wxPyEndAllowThreads(__tstate);
2794 if (PyErr_Occurred()) SWIG_fail;
2795 }
2796 resultobj = result;
2797 return resultobj;
2798 fail:
2799 return NULL;
2800 }
2801
2802
2803 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2804 PyObject *resultobj;
2805 wxColour *arg1 = (wxColour *) 0 ;
2806 unsigned long result;
2807 PyObject * obj0 = 0 ;
2808 char *kwnames[] = {
2809 (char *) "self", NULL
2810 };
2811
2812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2814 if (SWIG_arg_fail(1)) SWIG_fail;
2815 {
2816 PyThreadState* __tstate = wxPyBeginAllowThreads();
2817 result = (unsigned long)wxColour_GetRGB(arg1);
2818
2819 wxPyEndAllowThreads(__tstate);
2820 if (PyErr_Occurred()) SWIG_fail;
2821 }
2822 {
2823 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2824 }
2825 return resultobj;
2826 fail:
2827 return NULL;
2828 }
2829
2830
2831 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2832 PyObject *obj;
2833 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2834 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2835 Py_INCREF(obj);
2836 return Py_BuildValue((char *)"");
2837 }
2838 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2839 PyObject *resultobj;
2840 int arg1 ;
2841 unsigned char *arg2 = (unsigned char *) 0 ;
2842 unsigned char *arg3 = (unsigned char *) 0 ;
2843 unsigned char *arg4 = (unsigned char *) 0 ;
2844 wxPalette *result;
2845 PyObject * obj0 = 0 ;
2846 PyObject * obj1 = 0 ;
2847 PyObject * obj2 = 0 ;
2848 PyObject * obj3 = 0 ;
2849 char *kwnames[] = {
2850 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2851 };
2852
2853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2854 {
2855 arg1 = (int)(SWIG_As_int(obj0));
2856 if (SWIG_arg_fail(1)) SWIG_fail;
2857 }
2858 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2859 if (SWIG_arg_fail(2)) SWIG_fail;
2860 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2861 if (SWIG_arg_fail(3)) SWIG_fail;
2862 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2863 if (SWIG_arg_fail(4)) SWIG_fail;
2864 {
2865 if (!wxPyCheckForApp()) SWIG_fail;
2866 PyThreadState* __tstate = wxPyBeginAllowThreads();
2867 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2868
2869 wxPyEndAllowThreads(__tstate);
2870 if (PyErr_Occurred()) SWIG_fail;
2871 }
2872 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2873 return resultobj;
2874 fail:
2875 return NULL;
2876 }
2877
2878
2879 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2880 PyObject *resultobj;
2881 wxPalette *arg1 = (wxPalette *) 0 ;
2882 PyObject * obj0 = 0 ;
2883 char *kwnames[] = {
2884 (char *) "self", NULL
2885 };
2886
2887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2889 if (SWIG_arg_fail(1)) SWIG_fail;
2890 {
2891 PyThreadState* __tstate = wxPyBeginAllowThreads();
2892 delete arg1;
2893
2894 wxPyEndAllowThreads(__tstate);
2895 if (PyErr_Occurred()) SWIG_fail;
2896 }
2897 Py_INCREF(Py_None); resultobj = Py_None;
2898 return resultobj;
2899 fail:
2900 return NULL;
2901 }
2902
2903
2904 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2905 PyObject *resultobj;
2906 wxPalette *arg1 = (wxPalette *) 0 ;
2907 byte arg2 ;
2908 byte arg3 ;
2909 byte arg4 ;
2910 int result;
2911 PyObject * obj0 = 0 ;
2912 PyObject * obj1 = 0 ;
2913 PyObject * obj2 = 0 ;
2914 PyObject * obj3 = 0 ;
2915 char *kwnames[] = {
2916 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2917 };
2918
2919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2921 if (SWIG_arg_fail(1)) SWIG_fail;
2922 {
2923 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2924 if (SWIG_arg_fail(2)) SWIG_fail;
2925 }
2926 {
2927 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2928 if (SWIG_arg_fail(3)) SWIG_fail;
2929 }
2930 {
2931 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2932 if (SWIG_arg_fail(4)) SWIG_fail;
2933 }
2934 {
2935 PyThreadState* __tstate = wxPyBeginAllowThreads();
2936 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2937
2938 wxPyEndAllowThreads(__tstate);
2939 if (PyErr_Occurred()) SWIG_fail;
2940 }
2941 {
2942 resultobj = SWIG_From_int((int)(result));
2943 }
2944 return resultobj;
2945 fail:
2946 return NULL;
2947 }
2948
2949
2950 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2951 PyObject *resultobj;
2952 wxPalette *arg1 = (wxPalette *) 0 ;
2953 int arg2 ;
2954 byte *arg3 = (byte *) 0 ;
2955 byte *arg4 = (byte *) 0 ;
2956 byte *arg5 = (byte *) 0 ;
2957 bool result;
2958 byte temp3 ;
2959 int res3 = 0 ;
2960 byte temp4 ;
2961 int res4 = 0 ;
2962 byte temp5 ;
2963 int res5 = 0 ;
2964 PyObject * obj0 = 0 ;
2965 PyObject * obj1 = 0 ;
2966 char *kwnames[] = {
2967 (char *) "self",(char *) "pixel", NULL
2968 };
2969
2970 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2971 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2972 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2975 if (SWIG_arg_fail(1)) SWIG_fail;
2976 {
2977 arg2 = (int)(SWIG_As_int(obj1));
2978 if (SWIG_arg_fail(2)) SWIG_fail;
2979 }
2980 {
2981 PyThreadState* __tstate = wxPyBeginAllowThreads();
2982 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2983
2984 wxPyEndAllowThreads(__tstate);
2985 if (PyErr_Occurred()) SWIG_fail;
2986 }
2987 {
2988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2989 }
2990 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2991 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2992 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2993 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2994 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2995 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2996 return resultobj;
2997 fail:
2998 return NULL;
2999 }
3000
3001
3002 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
3003 PyObject *resultobj;
3004 wxPalette *arg1 = (wxPalette *) 0 ;
3005 int result;
3006 PyObject * obj0 = 0 ;
3007 char *kwnames[] = {
3008 (char *) "self", NULL
3009 };
3010
3011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
3012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3013 if (SWIG_arg_fail(1)) SWIG_fail;
3014 {
3015 PyThreadState* __tstate = wxPyBeginAllowThreads();
3016 result = (int)((wxPalette const *)arg1)->GetColoursCount();
3017
3018 wxPyEndAllowThreads(__tstate);
3019 if (PyErr_Occurred()) SWIG_fail;
3020 }
3021 {
3022 resultobj = SWIG_From_int((int)(result));
3023 }
3024 return resultobj;
3025 fail:
3026 return NULL;
3027 }
3028
3029
3030 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3031 PyObject *resultobj;
3032 wxPalette *arg1 = (wxPalette *) 0 ;
3033 bool result;
3034 PyObject * obj0 = 0 ;
3035 char *kwnames[] = {
3036 (char *) "self", NULL
3037 };
3038
3039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
3040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3041 if (SWIG_arg_fail(1)) SWIG_fail;
3042 {
3043 PyThreadState* __tstate = wxPyBeginAllowThreads();
3044 result = (bool)(arg1)->Ok();
3045
3046 wxPyEndAllowThreads(__tstate);
3047 if (PyErr_Occurred()) SWIG_fail;
3048 }
3049 {
3050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3051 }
3052 return resultobj;
3053 fail:
3054 return NULL;
3055 }
3056
3057
3058 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3059 PyObject *obj;
3060 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3061 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3062 Py_INCREF(obj);
3063 return Py_BuildValue((char *)"");
3064 }
3065 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3066 PyObject *resultobj;
3067 wxColour *arg1 = 0 ;
3068 int arg2 = (int) 1 ;
3069 int arg3 = (int) wxSOLID ;
3070 wxPen *result;
3071 wxColour temp1 ;
3072 PyObject * obj0 = 0 ;
3073 PyObject * obj1 = 0 ;
3074 PyObject * obj2 = 0 ;
3075 char *kwnames[] = {
3076 (char *) "colour",(char *) "width",(char *) "style", NULL
3077 };
3078
3079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3080 {
3081 arg1 = &temp1;
3082 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3083 }
3084 if (obj1) {
3085 {
3086 arg2 = (int)(SWIG_As_int(obj1));
3087 if (SWIG_arg_fail(2)) SWIG_fail;
3088 }
3089 }
3090 if (obj2) {
3091 {
3092 arg3 = (int)(SWIG_As_int(obj2));
3093 if (SWIG_arg_fail(3)) SWIG_fail;
3094 }
3095 }
3096 {
3097 if (!wxPyCheckForApp()) SWIG_fail;
3098 PyThreadState* __tstate = wxPyBeginAllowThreads();
3099 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3100
3101 wxPyEndAllowThreads(__tstate);
3102 if (PyErr_Occurred()) SWIG_fail;
3103 }
3104 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3105 return resultobj;
3106 fail:
3107 return NULL;
3108 }
3109
3110
3111 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3112 PyObject *resultobj;
3113 wxPen *arg1 = (wxPen *) 0 ;
3114 PyObject * obj0 = 0 ;
3115 char *kwnames[] = {
3116 (char *) "self", NULL
3117 };
3118
3119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3121 if (SWIG_arg_fail(1)) SWIG_fail;
3122 {
3123 PyThreadState* __tstate = wxPyBeginAllowThreads();
3124 delete arg1;
3125
3126 wxPyEndAllowThreads(__tstate);
3127 if (PyErr_Occurred()) SWIG_fail;
3128 }
3129 Py_INCREF(Py_None); resultobj = Py_None;
3130 return resultobj;
3131 fail:
3132 return NULL;
3133 }
3134
3135
3136 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3137 PyObject *resultobj;
3138 wxPen *arg1 = (wxPen *) 0 ;
3139 int result;
3140 PyObject * obj0 = 0 ;
3141 char *kwnames[] = {
3142 (char *) "self", NULL
3143 };
3144
3145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3147 if (SWIG_arg_fail(1)) SWIG_fail;
3148 {
3149 PyThreadState* __tstate = wxPyBeginAllowThreads();
3150 result = (int)(arg1)->GetCap();
3151
3152 wxPyEndAllowThreads(__tstate);
3153 if (PyErr_Occurred()) SWIG_fail;
3154 }
3155 {
3156 resultobj = SWIG_From_int((int)(result));
3157 }
3158 return resultobj;
3159 fail:
3160 return NULL;
3161 }
3162
3163
3164 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3165 PyObject *resultobj;
3166 wxPen *arg1 = (wxPen *) 0 ;
3167 wxColour result;
3168 PyObject * obj0 = 0 ;
3169 char *kwnames[] = {
3170 (char *) "self", NULL
3171 };
3172
3173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3175 if (SWIG_arg_fail(1)) SWIG_fail;
3176 {
3177 PyThreadState* __tstate = wxPyBeginAllowThreads();
3178 result = (arg1)->GetColour();
3179
3180 wxPyEndAllowThreads(__tstate);
3181 if (PyErr_Occurred()) SWIG_fail;
3182 }
3183 {
3184 wxColour * resultptr;
3185 resultptr = new wxColour((wxColour &)(result));
3186 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3187 }
3188 return resultobj;
3189 fail:
3190 return NULL;
3191 }
3192
3193
3194 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3195 PyObject *resultobj;
3196 wxPen *arg1 = (wxPen *) 0 ;
3197 int result;
3198 PyObject * obj0 = 0 ;
3199 char *kwnames[] = {
3200 (char *) "self", NULL
3201 };
3202
3203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3205 if (SWIG_arg_fail(1)) SWIG_fail;
3206 {
3207 PyThreadState* __tstate = wxPyBeginAllowThreads();
3208 result = (int)(arg1)->GetJoin();
3209
3210 wxPyEndAllowThreads(__tstate);
3211 if (PyErr_Occurred()) SWIG_fail;
3212 }
3213 {
3214 resultobj = SWIG_From_int((int)(result));
3215 }
3216 return resultobj;
3217 fail:
3218 return NULL;
3219 }
3220
3221
3222 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3223 PyObject *resultobj;
3224 wxPen *arg1 = (wxPen *) 0 ;
3225 int result;
3226 PyObject * obj0 = 0 ;
3227 char *kwnames[] = {
3228 (char *) "self", NULL
3229 };
3230
3231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3233 if (SWIG_arg_fail(1)) SWIG_fail;
3234 {
3235 PyThreadState* __tstate = wxPyBeginAllowThreads();
3236 result = (int)(arg1)->GetStyle();
3237
3238 wxPyEndAllowThreads(__tstate);
3239 if (PyErr_Occurred()) SWIG_fail;
3240 }
3241 {
3242 resultobj = SWIG_From_int((int)(result));
3243 }
3244 return resultobj;
3245 fail:
3246 return NULL;
3247 }
3248
3249
3250 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3251 PyObject *resultobj;
3252 wxPen *arg1 = (wxPen *) 0 ;
3253 int result;
3254 PyObject * obj0 = 0 ;
3255 char *kwnames[] = {
3256 (char *) "self", NULL
3257 };
3258
3259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3261 if (SWIG_arg_fail(1)) SWIG_fail;
3262 {
3263 PyThreadState* __tstate = wxPyBeginAllowThreads();
3264 result = (int)(arg1)->GetWidth();
3265
3266 wxPyEndAllowThreads(__tstate);
3267 if (PyErr_Occurred()) SWIG_fail;
3268 }
3269 {
3270 resultobj = SWIG_From_int((int)(result));
3271 }
3272 return resultobj;
3273 fail:
3274 return NULL;
3275 }
3276
3277
3278 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3279 PyObject *resultobj;
3280 wxPen *arg1 = (wxPen *) 0 ;
3281 bool result;
3282 PyObject * obj0 = 0 ;
3283 char *kwnames[] = {
3284 (char *) "self", NULL
3285 };
3286
3287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3289 if (SWIG_arg_fail(1)) SWIG_fail;
3290 {
3291 PyThreadState* __tstate = wxPyBeginAllowThreads();
3292 result = (bool)(arg1)->Ok();
3293
3294 wxPyEndAllowThreads(__tstate);
3295 if (PyErr_Occurred()) SWIG_fail;
3296 }
3297 {
3298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3299 }
3300 return resultobj;
3301 fail:
3302 return NULL;
3303 }
3304
3305
3306 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3307 PyObject *resultobj;
3308 wxPen *arg1 = (wxPen *) 0 ;
3309 int arg2 ;
3310 PyObject * obj0 = 0 ;
3311 PyObject * obj1 = 0 ;
3312 char *kwnames[] = {
3313 (char *) "self",(char *) "cap_style", NULL
3314 };
3315
3316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3318 if (SWIG_arg_fail(1)) SWIG_fail;
3319 {
3320 arg2 = (int)(SWIG_As_int(obj1));
3321 if (SWIG_arg_fail(2)) SWIG_fail;
3322 }
3323 {
3324 PyThreadState* __tstate = wxPyBeginAllowThreads();
3325 (arg1)->SetCap(arg2);
3326
3327 wxPyEndAllowThreads(__tstate);
3328 if (PyErr_Occurred()) SWIG_fail;
3329 }
3330 Py_INCREF(Py_None); resultobj = Py_None;
3331 return resultobj;
3332 fail:
3333 return NULL;
3334 }
3335
3336
3337 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3338 PyObject *resultobj;
3339 wxPen *arg1 = (wxPen *) 0 ;
3340 wxColour *arg2 = 0 ;
3341 wxColour temp2 ;
3342 PyObject * obj0 = 0 ;
3343 PyObject * obj1 = 0 ;
3344 char *kwnames[] = {
3345 (char *) "self",(char *) "colour", NULL
3346 };
3347
3348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3350 if (SWIG_arg_fail(1)) SWIG_fail;
3351 {
3352 arg2 = &temp2;
3353 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3354 }
3355 {
3356 PyThreadState* __tstate = wxPyBeginAllowThreads();
3357 (arg1)->SetColour(*arg2);
3358
3359 wxPyEndAllowThreads(__tstate);
3360 if (PyErr_Occurred()) SWIG_fail;
3361 }
3362 Py_INCREF(Py_None); resultobj = Py_None;
3363 return resultobj;
3364 fail:
3365 return NULL;
3366 }
3367
3368
3369 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3370 PyObject *resultobj;
3371 wxPen *arg1 = (wxPen *) 0 ;
3372 int arg2 ;
3373 PyObject * obj0 = 0 ;
3374 PyObject * obj1 = 0 ;
3375 char *kwnames[] = {
3376 (char *) "self",(char *) "join_style", NULL
3377 };
3378
3379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3381 if (SWIG_arg_fail(1)) SWIG_fail;
3382 {
3383 arg2 = (int)(SWIG_As_int(obj1));
3384 if (SWIG_arg_fail(2)) SWIG_fail;
3385 }
3386 {
3387 PyThreadState* __tstate = wxPyBeginAllowThreads();
3388 (arg1)->SetJoin(arg2);
3389
3390 wxPyEndAllowThreads(__tstate);
3391 if (PyErr_Occurred()) SWIG_fail;
3392 }
3393 Py_INCREF(Py_None); resultobj = Py_None;
3394 return resultobj;
3395 fail:
3396 return NULL;
3397 }
3398
3399
3400 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3401 PyObject *resultobj;
3402 wxPen *arg1 = (wxPen *) 0 ;
3403 int arg2 ;
3404 PyObject * obj0 = 0 ;
3405 PyObject * obj1 = 0 ;
3406 char *kwnames[] = {
3407 (char *) "self",(char *) "style", NULL
3408 };
3409
3410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3412 if (SWIG_arg_fail(1)) SWIG_fail;
3413 {
3414 arg2 = (int)(SWIG_As_int(obj1));
3415 if (SWIG_arg_fail(2)) SWIG_fail;
3416 }
3417 {
3418 PyThreadState* __tstate = wxPyBeginAllowThreads();
3419 (arg1)->SetStyle(arg2);
3420
3421 wxPyEndAllowThreads(__tstate);
3422 if (PyErr_Occurred()) SWIG_fail;
3423 }
3424 Py_INCREF(Py_None); resultobj = Py_None;
3425 return resultobj;
3426 fail:
3427 return NULL;
3428 }
3429
3430
3431 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3432 PyObject *resultobj;
3433 wxPen *arg1 = (wxPen *) 0 ;
3434 int arg2 ;
3435 PyObject * obj0 = 0 ;
3436 PyObject * obj1 = 0 ;
3437 char *kwnames[] = {
3438 (char *) "self",(char *) "width", NULL
3439 };
3440
3441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3443 if (SWIG_arg_fail(1)) SWIG_fail;
3444 {
3445 arg2 = (int)(SWIG_As_int(obj1));
3446 if (SWIG_arg_fail(2)) SWIG_fail;
3447 }
3448 {
3449 PyThreadState* __tstate = wxPyBeginAllowThreads();
3450 (arg1)->SetWidth(arg2);
3451
3452 wxPyEndAllowThreads(__tstate);
3453 if (PyErr_Occurred()) SWIG_fail;
3454 }
3455 Py_INCREF(Py_None); resultobj = Py_None;
3456 return resultobj;
3457 fail:
3458 return NULL;
3459 }
3460
3461
3462 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3463 PyObject *resultobj;
3464 wxPen *arg1 = (wxPen *) 0 ;
3465 int arg2 ;
3466 wxDash *arg3 = (wxDash *) 0 ;
3467 PyObject * obj0 = 0 ;
3468 PyObject * obj1 = 0 ;
3469 char *kwnames[] = {
3470 (char *) "self",(char *) "dashes", NULL
3471 };
3472
3473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3475 if (SWIG_arg_fail(1)) SWIG_fail;
3476 {
3477 arg2 = PyList_Size(obj1);
3478 arg3 = (wxDash*)byte_LIST_helper(obj1);
3479 if (arg3 == NULL) SWIG_fail;
3480 }
3481 {
3482 PyThreadState* __tstate = wxPyBeginAllowThreads();
3483 (arg1)->SetDashes(arg2,arg3);
3484
3485 wxPyEndAllowThreads(__tstate);
3486 if (PyErr_Occurred()) SWIG_fail;
3487 }
3488 Py_INCREF(Py_None); resultobj = Py_None;
3489 {
3490 if (arg3) delete [] arg3;
3491 }
3492 return resultobj;
3493 fail:
3494 {
3495 if (arg3) delete [] arg3;
3496 }
3497 return NULL;
3498 }
3499
3500
3501 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3502 PyObject *resultobj;
3503 wxPen *arg1 = (wxPen *) 0 ;
3504 PyObject *result;
3505 PyObject * obj0 = 0 ;
3506 char *kwnames[] = {
3507 (char *) "self", NULL
3508 };
3509
3510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3512 if (SWIG_arg_fail(1)) SWIG_fail;
3513 {
3514 PyThreadState* __tstate = wxPyBeginAllowThreads();
3515 result = (PyObject *)wxPen_GetDashes(arg1);
3516
3517 wxPyEndAllowThreads(__tstate);
3518 if (PyErr_Occurred()) SWIG_fail;
3519 }
3520 resultobj = result;
3521 return resultobj;
3522 fail:
3523 return NULL;
3524 }
3525
3526
3527 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3528 PyObject *resultobj;
3529 wxPen *arg1 = (wxPen *) 0 ;
3530 PyObject *arg2 = (PyObject *) 0 ;
3531 PyObject *arg3 = (PyObject *) 0 ;
3532 PyObject * obj0 = 0 ;
3533 PyObject * obj1 = 0 ;
3534 PyObject * obj2 = 0 ;
3535 char *kwnames[] = {
3536 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3537 };
3538
3539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3541 if (SWIG_arg_fail(1)) SWIG_fail;
3542 arg2 = obj1;
3543 arg3 = obj2;
3544 {
3545 PyThreadState* __tstate = wxPyBeginAllowThreads();
3546 wxPen__SetDashes(arg1,arg2,arg3);
3547
3548 wxPyEndAllowThreads(__tstate);
3549 if (PyErr_Occurred()) SWIG_fail;
3550 }
3551 Py_INCREF(Py_None); resultobj = Py_None;
3552 return resultobj;
3553 fail:
3554 return NULL;
3555 }
3556
3557
3558 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3559 PyObject *resultobj;
3560 wxPen *arg1 = (wxPen *) 0 ;
3561 wxPen *arg2 = (wxPen *) 0 ;
3562 bool result;
3563 PyObject * obj0 = 0 ;
3564 PyObject * obj1 = 0 ;
3565 char *kwnames[] = {
3566 (char *) "self",(char *) "other", NULL
3567 };
3568
3569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3571 if (SWIG_arg_fail(1)) SWIG_fail;
3572 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3573 if (SWIG_arg_fail(2)) SWIG_fail;
3574 {
3575 PyThreadState* __tstate = wxPyBeginAllowThreads();
3576 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3577
3578 wxPyEndAllowThreads(__tstate);
3579 if (PyErr_Occurred()) SWIG_fail;
3580 }
3581 {
3582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3583 }
3584 return resultobj;
3585 fail:
3586 return NULL;
3587 }
3588
3589
3590 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3591 PyObject *resultobj;
3592 wxPen *arg1 = (wxPen *) 0 ;
3593 wxPen *arg2 = (wxPen *) 0 ;
3594 bool result;
3595 PyObject * obj0 = 0 ;
3596 PyObject * obj1 = 0 ;
3597 char *kwnames[] = {
3598 (char *) "self",(char *) "other", NULL
3599 };
3600
3601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3603 if (SWIG_arg_fail(1)) SWIG_fail;
3604 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3605 if (SWIG_arg_fail(2)) SWIG_fail;
3606 {
3607 PyThreadState* __tstate = wxPyBeginAllowThreads();
3608 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3609
3610 wxPyEndAllowThreads(__tstate);
3611 if (PyErr_Occurred()) SWIG_fail;
3612 }
3613 {
3614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3615 }
3616 return resultobj;
3617 fail:
3618 return NULL;
3619 }
3620
3621
3622 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3623 PyObject *obj;
3624 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3625 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3626 Py_INCREF(obj);
3627 return Py_BuildValue((char *)"");
3628 }
3629 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3630 PyObject *resultobj;
3631 wxColour *arg1 = 0 ;
3632 int arg2 = (int) wxSOLID ;
3633 wxBrush *result;
3634 wxColour temp1 ;
3635 PyObject * obj0 = 0 ;
3636 PyObject * obj1 = 0 ;
3637 char *kwnames[] = {
3638 (char *) "colour",(char *) "style", NULL
3639 };
3640
3641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3642 {
3643 arg1 = &temp1;
3644 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3645 }
3646 if (obj1) {
3647 {
3648 arg2 = (int)(SWIG_As_int(obj1));
3649 if (SWIG_arg_fail(2)) SWIG_fail;
3650 }
3651 }
3652 {
3653 if (!wxPyCheckForApp()) SWIG_fail;
3654 PyThreadState* __tstate = wxPyBeginAllowThreads();
3655 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3656
3657 wxPyEndAllowThreads(__tstate);
3658 if (PyErr_Occurred()) SWIG_fail;
3659 }
3660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3661 return resultobj;
3662 fail:
3663 return NULL;
3664 }
3665
3666
3667 static PyObject *_wrap_new_BrushFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3668 PyObject *resultobj;
3669 wxBitmap *arg1 = 0 ;
3670 wxBrush *result;
3671 PyObject * obj0 = 0 ;
3672 char *kwnames[] = {
3673 (char *) "stippleBitmap", NULL
3674 };
3675
3676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BrushFromBitmap",kwnames,&obj0)) goto fail;
3677 {
3678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3679 if (SWIG_arg_fail(1)) SWIG_fail;
3680 if (arg1 == NULL) {
3681 SWIG_null_ref("wxBitmap");
3682 }
3683 if (SWIG_arg_fail(1)) SWIG_fail;
3684 }
3685 {
3686 if (!wxPyCheckForApp()) SWIG_fail;
3687 PyThreadState* __tstate = wxPyBeginAllowThreads();
3688 result = (wxBrush *)new wxBrush((wxBitmap const &)*arg1);
3689
3690 wxPyEndAllowThreads(__tstate);
3691 if (PyErr_Occurred()) SWIG_fail;
3692 }
3693 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3694 return resultobj;
3695 fail:
3696 return NULL;
3697 }
3698
3699
3700 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3701 PyObject *resultobj;
3702 wxBrush *arg1 = (wxBrush *) 0 ;
3703 PyObject * obj0 = 0 ;
3704 char *kwnames[] = {
3705 (char *) "self", NULL
3706 };
3707
3708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3710 if (SWIG_arg_fail(1)) SWIG_fail;
3711 {
3712 PyThreadState* __tstate = wxPyBeginAllowThreads();
3713 delete arg1;
3714
3715 wxPyEndAllowThreads(__tstate);
3716 if (PyErr_Occurred()) SWIG_fail;
3717 }
3718 Py_INCREF(Py_None); resultobj = Py_None;
3719 return resultobj;
3720 fail:
3721 return NULL;
3722 }
3723
3724
3725 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3726 PyObject *resultobj;
3727 wxBrush *arg1 = (wxBrush *) 0 ;
3728 wxColour *arg2 = 0 ;
3729 wxColour temp2 ;
3730 PyObject * obj0 = 0 ;
3731 PyObject * obj1 = 0 ;
3732 char *kwnames[] = {
3733 (char *) "self",(char *) "col", NULL
3734 };
3735
3736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3738 if (SWIG_arg_fail(1)) SWIG_fail;
3739 {
3740 arg2 = &temp2;
3741 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3742 }
3743 {
3744 PyThreadState* __tstate = wxPyBeginAllowThreads();
3745 (arg1)->SetColour((wxColour const &)*arg2);
3746
3747 wxPyEndAllowThreads(__tstate);
3748 if (PyErr_Occurred()) SWIG_fail;
3749 }
3750 Py_INCREF(Py_None); resultobj = Py_None;
3751 return resultobj;
3752 fail:
3753 return NULL;
3754 }
3755
3756
3757 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3758 PyObject *resultobj;
3759 wxBrush *arg1 = (wxBrush *) 0 ;
3760 int arg2 ;
3761 PyObject * obj0 = 0 ;
3762 PyObject * obj1 = 0 ;
3763 char *kwnames[] = {
3764 (char *) "self",(char *) "style", NULL
3765 };
3766
3767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3769 if (SWIG_arg_fail(1)) SWIG_fail;
3770 {
3771 arg2 = (int)(SWIG_As_int(obj1));
3772 if (SWIG_arg_fail(2)) SWIG_fail;
3773 }
3774 {
3775 PyThreadState* __tstate = wxPyBeginAllowThreads();
3776 (arg1)->SetStyle(arg2);
3777
3778 wxPyEndAllowThreads(__tstate);
3779 if (PyErr_Occurred()) SWIG_fail;
3780 }
3781 Py_INCREF(Py_None); resultobj = Py_None;
3782 return resultobj;
3783 fail:
3784 return NULL;
3785 }
3786
3787
3788 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3789 PyObject *resultobj;
3790 wxBrush *arg1 = (wxBrush *) 0 ;
3791 wxBitmap *arg2 = 0 ;
3792 PyObject * obj0 = 0 ;
3793 PyObject * obj1 = 0 ;
3794 char *kwnames[] = {
3795 (char *) "self",(char *) "stipple", NULL
3796 };
3797
3798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3800 if (SWIG_arg_fail(1)) SWIG_fail;
3801 {
3802 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3803 if (SWIG_arg_fail(2)) SWIG_fail;
3804 if (arg2 == NULL) {
3805 SWIG_null_ref("wxBitmap");
3806 }
3807 if (SWIG_arg_fail(2)) SWIG_fail;
3808 }
3809 {
3810 PyThreadState* __tstate = wxPyBeginAllowThreads();
3811 (arg1)->SetStipple((wxBitmap const &)*arg2);
3812
3813 wxPyEndAllowThreads(__tstate);
3814 if (PyErr_Occurred()) SWIG_fail;
3815 }
3816 Py_INCREF(Py_None); resultobj = Py_None;
3817 return resultobj;
3818 fail:
3819 return NULL;
3820 }
3821
3822
3823 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3824 PyObject *resultobj;
3825 wxBrush *arg1 = (wxBrush *) 0 ;
3826 wxColour result;
3827 PyObject * obj0 = 0 ;
3828 char *kwnames[] = {
3829 (char *) "self", NULL
3830 };
3831
3832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3834 if (SWIG_arg_fail(1)) SWIG_fail;
3835 {
3836 PyThreadState* __tstate = wxPyBeginAllowThreads();
3837 result = ((wxBrush const *)arg1)->GetColour();
3838
3839 wxPyEndAllowThreads(__tstate);
3840 if (PyErr_Occurred()) SWIG_fail;
3841 }
3842 {
3843 wxColour * resultptr;
3844 resultptr = new wxColour((wxColour &)(result));
3845 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3846 }
3847 return resultobj;
3848 fail:
3849 return NULL;
3850 }
3851
3852
3853 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3854 PyObject *resultobj;
3855 wxBrush *arg1 = (wxBrush *) 0 ;
3856 int result;
3857 PyObject * obj0 = 0 ;
3858 char *kwnames[] = {
3859 (char *) "self", NULL
3860 };
3861
3862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3864 if (SWIG_arg_fail(1)) SWIG_fail;
3865 {
3866 PyThreadState* __tstate = wxPyBeginAllowThreads();
3867 result = (int)((wxBrush const *)arg1)->GetStyle();
3868
3869 wxPyEndAllowThreads(__tstate);
3870 if (PyErr_Occurred()) SWIG_fail;
3871 }
3872 {
3873 resultobj = SWIG_From_int((int)(result));
3874 }
3875 return resultobj;
3876 fail:
3877 return NULL;
3878 }
3879
3880
3881 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3882 PyObject *resultobj;
3883 wxBrush *arg1 = (wxBrush *) 0 ;
3884 wxBitmap *result;
3885 PyObject * obj0 = 0 ;
3886 char *kwnames[] = {
3887 (char *) "self", NULL
3888 };
3889
3890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3892 if (SWIG_arg_fail(1)) SWIG_fail;
3893 {
3894 PyThreadState* __tstate = wxPyBeginAllowThreads();
3895 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3896
3897 wxPyEndAllowThreads(__tstate);
3898 if (PyErr_Occurred()) SWIG_fail;
3899 }
3900 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3901 return resultobj;
3902 fail:
3903 return NULL;
3904 }
3905
3906
3907 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3908 PyObject *resultobj;
3909 wxBrush *arg1 = (wxBrush *) 0 ;
3910 bool result;
3911 PyObject * obj0 = 0 ;
3912 char *kwnames[] = {
3913 (char *) "self", NULL
3914 };
3915
3916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3918 if (SWIG_arg_fail(1)) SWIG_fail;
3919 {
3920 PyThreadState* __tstate = wxPyBeginAllowThreads();
3921 result = (bool)((wxBrush const *)arg1)->IsHatch();
3922
3923 wxPyEndAllowThreads(__tstate);
3924 if (PyErr_Occurred()) SWIG_fail;
3925 }
3926 {
3927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3928 }
3929 return resultobj;
3930 fail:
3931 return NULL;
3932 }
3933
3934
3935 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3936 PyObject *resultobj;
3937 wxBrush *arg1 = (wxBrush *) 0 ;
3938 bool result;
3939 PyObject * obj0 = 0 ;
3940 char *kwnames[] = {
3941 (char *) "self", NULL
3942 };
3943
3944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3946 if (SWIG_arg_fail(1)) SWIG_fail;
3947 {
3948 PyThreadState* __tstate = wxPyBeginAllowThreads();
3949 result = (bool)(arg1)->Ok();
3950
3951 wxPyEndAllowThreads(__tstate);
3952 if (PyErr_Occurred()) SWIG_fail;
3953 }
3954 {
3955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3956 }
3957 return resultobj;
3958 fail:
3959 return NULL;
3960 }
3961
3962
3963 static PyObject *_wrap_Brush_MacGetTheme(PyObject *, PyObject *args, PyObject *kwargs) {
3964 PyObject *resultobj;
3965 wxBrush *arg1 = (wxBrush *) 0 ;
3966 short result;
3967 PyObject * obj0 = 0 ;
3968 char *kwnames[] = {
3969 (char *) "self", NULL
3970 };
3971
3972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_MacGetTheme",kwnames,&obj0)) goto fail;
3973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3974 if (SWIG_arg_fail(1)) SWIG_fail;
3975 {
3976 PyThreadState* __tstate = wxPyBeginAllowThreads();
3977 result = (short)(arg1)->MacGetTheme();
3978
3979 wxPyEndAllowThreads(__tstate);
3980 if (PyErr_Occurred()) SWIG_fail;
3981 }
3982 {
3983 resultobj = SWIG_From_short((short)(result));
3984 }
3985 return resultobj;
3986 fail:
3987 return NULL;
3988 }
3989
3990
3991 static PyObject *_wrap_Brush_MacSetTheme(PyObject *, PyObject *args, PyObject *kwargs) {
3992 PyObject *resultobj;
3993 wxBrush *arg1 = (wxBrush *) 0 ;
3994 short arg2 ;
3995 PyObject * obj0 = 0 ;
3996 PyObject * obj1 = 0 ;
3997 char *kwnames[] = {
3998 (char *) "self",(char *) "macThemeBrush", NULL
3999 };
4000
4001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_MacSetTheme",kwnames,&obj0,&obj1)) goto fail;
4002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
4003 if (SWIG_arg_fail(1)) SWIG_fail;
4004 {
4005 arg2 = (short)(SWIG_As_short(obj1));
4006 if (SWIG_arg_fail(2)) SWIG_fail;
4007 }
4008 {
4009 PyThreadState* __tstate = wxPyBeginAllowThreads();
4010 (arg1)->MacSetTheme(arg2);
4011
4012 wxPyEndAllowThreads(__tstate);
4013 if (PyErr_Occurred()) SWIG_fail;
4014 }
4015 Py_INCREF(Py_None); resultobj = Py_None;
4016 return resultobj;
4017 fail:
4018 return NULL;
4019 }
4020
4021
4022 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
4023 PyObject *obj;
4024 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4025 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
4026 Py_INCREF(obj);
4027 return Py_BuildValue((char *)"");
4028 }
4029 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4030 PyObject *resultobj;
4031 wxString *arg1 = 0 ;
4032 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
4033 wxBitmap *result;
4034 bool temp1 = false ;
4035 PyObject * obj0 = 0 ;
4036 PyObject * obj1 = 0 ;
4037 char *kwnames[] = {
4038 (char *) "name",(char *) "type", NULL
4039 };
4040
4041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
4042 {
4043 arg1 = wxString_in_helper(obj0);
4044 if (arg1 == NULL) SWIG_fail;
4045 temp1 = true;
4046 }
4047 if (obj1) {
4048 {
4049 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4050 if (SWIG_arg_fail(2)) SWIG_fail;
4051 }
4052 }
4053 {
4054 if (!wxPyCheckForApp()) SWIG_fail;
4055 PyThreadState* __tstate = wxPyBeginAllowThreads();
4056 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
4057
4058 wxPyEndAllowThreads(__tstate);
4059 if (PyErr_Occurred()) SWIG_fail;
4060 }
4061 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4062 {
4063 if (temp1)
4064 delete arg1;
4065 }
4066 return resultobj;
4067 fail:
4068 {
4069 if (temp1)
4070 delete arg1;
4071 }
4072 return NULL;
4073 }
4074
4075
4076 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4077 PyObject *resultobj;
4078 wxBitmap *arg1 = (wxBitmap *) 0 ;
4079 PyObject * obj0 = 0 ;
4080 char *kwnames[] = {
4081 (char *) "self", NULL
4082 };
4083
4084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
4085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4086 if (SWIG_arg_fail(1)) SWIG_fail;
4087 {
4088 PyThreadState* __tstate = wxPyBeginAllowThreads();
4089 delete arg1;
4090
4091 wxPyEndAllowThreads(__tstate);
4092 if (PyErr_Occurred()) SWIG_fail;
4093 }
4094 Py_INCREF(Py_None); resultobj = Py_None;
4095 return resultobj;
4096 fail:
4097 return NULL;
4098 }
4099
4100
4101 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4102 PyObject *resultobj;
4103 int arg1 ;
4104 int arg2 ;
4105 int arg3 = (int) -1 ;
4106 wxBitmap *result;
4107 PyObject * obj0 = 0 ;
4108 PyObject * obj1 = 0 ;
4109 PyObject * obj2 = 0 ;
4110 char *kwnames[] = {
4111 (char *) "width",(char *) "height",(char *) "depth", NULL
4112 };
4113
4114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4115 {
4116 arg1 = (int)(SWIG_As_int(obj0));
4117 if (SWIG_arg_fail(1)) SWIG_fail;
4118 }
4119 {
4120 arg2 = (int)(SWIG_As_int(obj1));
4121 if (SWIG_arg_fail(2)) SWIG_fail;
4122 }
4123 if (obj2) {
4124 {
4125 arg3 = (int)(SWIG_As_int(obj2));
4126 if (SWIG_arg_fail(3)) SWIG_fail;
4127 }
4128 }
4129 {
4130 if (!wxPyCheckForApp()) SWIG_fail;
4131 PyThreadState* __tstate = wxPyBeginAllowThreads();
4132 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4133
4134 wxPyEndAllowThreads(__tstate);
4135 if (PyErr_Occurred()) SWIG_fail;
4136 }
4137 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4138 return resultobj;
4139 fail:
4140 return NULL;
4141 }
4142
4143
4144 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4145 PyObject *resultobj;
4146 wxIcon *arg1 = 0 ;
4147 wxBitmap *result;
4148 PyObject * obj0 = 0 ;
4149 char *kwnames[] = {
4150 (char *) "icon", NULL
4151 };
4152
4153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4154 {
4155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4156 if (SWIG_arg_fail(1)) SWIG_fail;
4157 if (arg1 == NULL) {
4158 SWIG_null_ref("wxIcon");
4159 }
4160 if (SWIG_arg_fail(1)) SWIG_fail;
4161 }
4162 {
4163 if (!wxPyCheckForApp()) SWIG_fail;
4164 PyThreadState* __tstate = wxPyBeginAllowThreads();
4165 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4166
4167 wxPyEndAllowThreads(__tstate);
4168 if (PyErr_Occurred()) SWIG_fail;
4169 }
4170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4171 return resultobj;
4172 fail:
4173 return NULL;
4174 }
4175
4176
4177 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4178 PyObject *resultobj;
4179 wxImage *arg1 = 0 ;
4180 int arg2 = (int) -1 ;
4181 wxBitmap *result;
4182 PyObject * obj0 = 0 ;
4183 PyObject * obj1 = 0 ;
4184 char *kwnames[] = {
4185 (char *) "image",(char *) "depth", NULL
4186 };
4187
4188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4189 {
4190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4191 if (SWIG_arg_fail(1)) SWIG_fail;
4192 if (arg1 == NULL) {
4193 SWIG_null_ref("wxImage");
4194 }
4195 if (SWIG_arg_fail(1)) SWIG_fail;
4196 }
4197 if (obj1) {
4198 {
4199 arg2 = (int)(SWIG_As_int(obj1));
4200 if (SWIG_arg_fail(2)) SWIG_fail;
4201 }
4202 }
4203 {
4204 if (!wxPyCheckForApp()) SWIG_fail;
4205 PyThreadState* __tstate = wxPyBeginAllowThreads();
4206 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4207
4208 wxPyEndAllowThreads(__tstate);
4209 if (PyErr_Occurred()) SWIG_fail;
4210 }
4211 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4212 return resultobj;
4213 fail:
4214 return NULL;
4215 }
4216
4217
4218 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4219 PyObject *resultobj;
4220 PyObject *arg1 = (PyObject *) 0 ;
4221 wxBitmap *result;
4222 PyObject * obj0 = 0 ;
4223 char *kwnames[] = {
4224 (char *) "listOfStrings", NULL
4225 };
4226
4227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4228 arg1 = obj0;
4229 {
4230 if (!wxPyCheckForApp()) SWIG_fail;
4231 PyThreadState* __tstate = wxPyBeginAllowThreads();
4232 result = (wxBitmap *)new_wxBitmap(arg1);
4233
4234 wxPyEndAllowThreads(__tstate);
4235 if (PyErr_Occurred()) SWIG_fail;
4236 }
4237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4238 return resultobj;
4239 fail:
4240 return NULL;
4241 }
4242
4243
4244 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4245 PyObject *resultobj;
4246 PyObject *arg1 = (PyObject *) 0 ;
4247 int arg2 ;
4248 int arg3 ;
4249 int arg4 = (int) 1 ;
4250 wxBitmap *result;
4251 PyObject * obj0 = 0 ;
4252 PyObject * obj1 = 0 ;
4253 PyObject * obj2 = 0 ;
4254 PyObject * obj3 = 0 ;
4255 char *kwnames[] = {
4256 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4257 };
4258
4259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4260 arg1 = obj0;
4261 {
4262 arg2 = (int)(SWIG_As_int(obj1));
4263 if (SWIG_arg_fail(2)) SWIG_fail;
4264 }
4265 {
4266 arg3 = (int)(SWIG_As_int(obj2));
4267 if (SWIG_arg_fail(3)) SWIG_fail;
4268 }
4269 if (obj3) {
4270 {
4271 arg4 = (int)(SWIG_As_int(obj3));
4272 if (SWIG_arg_fail(4)) SWIG_fail;
4273 }
4274 }
4275 {
4276 if (!wxPyCheckForApp()) SWIG_fail;
4277 PyThreadState* __tstate = wxPyBeginAllowThreads();
4278 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4279
4280 wxPyEndAllowThreads(__tstate);
4281 if (PyErr_Occurred()) SWIG_fail;
4282 }
4283 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4284 return resultobj;
4285 fail:
4286 return NULL;
4287 }
4288
4289
4290 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4291 PyObject *resultobj;
4292 wxBitmap *arg1 = (wxBitmap *) 0 ;
4293 bool result;
4294 PyObject * obj0 = 0 ;
4295 char *kwnames[] = {
4296 (char *) "self", NULL
4297 };
4298
4299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4301 if (SWIG_arg_fail(1)) SWIG_fail;
4302 {
4303 PyThreadState* __tstate = wxPyBeginAllowThreads();
4304 result = (bool)(arg1)->Ok();
4305
4306 wxPyEndAllowThreads(__tstate);
4307 if (PyErr_Occurred()) SWIG_fail;
4308 }
4309 {
4310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4311 }
4312 return resultobj;
4313 fail:
4314 return NULL;
4315 }
4316
4317
4318 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4319 PyObject *resultobj;
4320 wxBitmap *arg1 = (wxBitmap *) 0 ;
4321 int result;
4322 PyObject * obj0 = 0 ;
4323 char *kwnames[] = {
4324 (char *) "self", NULL
4325 };
4326
4327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4329 if (SWIG_arg_fail(1)) SWIG_fail;
4330 {
4331 PyThreadState* __tstate = wxPyBeginAllowThreads();
4332 result = (int)(arg1)->GetWidth();
4333
4334 wxPyEndAllowThreads(__tstate);
4335 if (PyErr_Occurred()) SWIG_fail;
4336 }
4337 {
4338 resultobj = SWIG_From_int((int)(result));
4339 }
4340 return resultobj;
4341 fail:
4342 return NULL;
4343 }
4344
4345
4346 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4347 PyObject *resultobj;
4348 wxBitmap *arg1 = (wxBitmap *) 0 ;
4349 int result;
4350 PyObject * obj0 = 0 ;
4351 char *kwnames[] = {
4352 (char *) "self", NULL
4353 };
4354
4355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4357 if (SWIG_arg_fail(1)) SWIG_fail;
4358 {
4359 PyThreadState* __tstate = wxPyBeginAllowThreads();
4360 result = (int)(arg1)->GetHeight();
4361
4362 wxPyEndAllowThreads(__tstate);
4363 if (PyErr_Occurred()) SWIG_fail;
4364 }
4365 {
4366 resultobj = SWIG_From_int((int)(result));
4367 }
4368 return resultobj;
4369 fail:
4370 return NULL;
4371 }
4372
4373
4374 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4375 PyObject *resultobj;
4376 wxBitmap *arg1 = (wxBitmap *) 0 ;
4377 int result;
4378 PyObject * obj0 = 0 ;
4379 char *kwnames[] = {
4380 (char *) "self", NULL
4381 };
4382
4383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4385 if (SWIG_arg_fail(1)) SWIG_fail;
4386 {
4387 PyThreadState* __tstate = wxPyBeginAllowThreads();
4388 result = (int)(arg1)->GetDepth();
4389
4390 wxPyEndAllowThreads(__tstate);
4391 if (PyErr_Occurred()) SWIG_fail;
4392 }
4393 {
4394 resultobj = SWIG_From_int((int)(result));
4395 }
4396 return resultobj;
4397 fail:
4398 return NULL;
4399 }
4400
4401
4402 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4403 PyObject *resultobj;
4404 wxBitmap *arg1 = (wxBitmap *) 0 ;
4405 wxSize result;
4406 PyObject * obj0 = 0 ;
4407 char *kwnames[] = {
4408 (char *) "self", NULL
4409 };
4410
4411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4413 if (SWIG_arg_fail(1)) SWIG_fail;
4414 {
4415 PyThreadState* __tstate = wxPyBeginAllowThreads();
4416 result = wxBitmap_GetSize(arg1);
4417
4418 wxPyEndAllowThreads(__tstate);
4419 if (PyErr_Occurred()) SWIG_fail;
4420 }
4421 {
4422 wxSize * resultptr;
4423 resultptr = new wxSize((wxSize &)(result));
4424 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4425 }
4426 return resultobj;
4427 fail:
4428 return NULL;
4429 }
4430
4431
4432 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4433 PyObject *resultobj;
4434 wxBitmap *arg1 = (wxBitmap *) 0 ;
4435 SwigValueWrapper<wxImage > result;
4436 PyObject * obj0 = 0 ;
4437 char *kwnames[] = {
4438 (char *) "self", NULL
4439 };
4440
4441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4443 if (SWIG_arg_fail(1)) SWIG_fail;
4444 {
4445 PyThreadState* __tstate = wxPyBeginAllowThreads();
4446 result = ((wxBitmap const *)arg1)->ConvertToImage();
4447
4448 wxPyEndAllowThreads(__tstate);
4449 if (PyErr_Occurred()) SWIG_fail;
4450 }
4451 {
4452 wxImage * resultptr;
4453 resultptr = new wxImage((wxImage &)(result));
4454 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4455 }
4456 return resultobj;
4457 fail:
4458 return NULL;
4459 }
4460
4461
4462 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4463 PyObject *resultobj;
4464 wxBitmap *arg1 = (wxBitmap *) 0 ;
4465 wxMask *result;
4466 PyObject * obj0 = 0 ;
4467 char *kwnames[] = {
4468 (char *) "self", NULL
4469 };
4470
4471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4473 if (SWIG_arg_fail(1)) SWIG_fail;
4474 {
4475 PyThreadState* __tstate = wxPyBeginAllowThreads();
4476 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4477
4478 wxPyEndAllowThreads(__tstate);
4479 if (PyErr_Occurred()) SWIG_fail;
4480 }
4481 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4482 return resultobj;
4483 fail:
4484 return NULL;
4485 }
4486
4487
4488 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4489 PyObject *resultobj;
4490 wxBitmap *arg1 = (wxBitmap *) 0 ;
4491 wxMask *arg2 = (wxMask *) 0 ;
4492 PyObject * obj0 = 0 ;
4493 PyObject * obj1 = 0 ;
4494 char *kwnames[] = {
4495 (char *) "self",(char *) "mask", NULL
4496 };
4497
4498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4500 if (SWIG_arg_fail(1)) SWIG_fail;
4501 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4502 if (SWIG_arg_fail(2)) SWIG_fail;
4503 {
4504 PyThreadState* __tstate = wxPyBeginAllowThreads();
4505 (arg1)->SetMask(arg2);
4506
4507 wxPyEndAllowThreads(__tstate);
4508 if (PyErr_Occurred()) SWIG_fail;
4509 }
4510 Py_INCREF(Py_None); resultobj = Py_None;
4511 return resultobj;
4512 fail:
4513 return NULL;
4514 }
4515
4516
4517 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4518 PyObject *resultobj;
4519 wxBitmap *arg1 = (wxBitmap *) 0 ;
4520 wxColour *arg2 = 0 ;
4521 wxColour temp2 ;
4522 PyObject * obj0 = 0 ;
4523 PyObject * obj1 = 0 ;
4524 char *kwnames[] = {
4525 (char *) "self",(char *) "colour", NULL
4526 };
4527
4528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4530 if (SWIG_arg_fail(1)) SWIG_fail;
4531 {
4532 arg2 = &temp2;
4533 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4534 }
4535 {
4536 PyThreadState* __tstate = wxPyBeginAllowThreads();
4537 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4538
4539 wxPyEndAllowThreads(__tstate);
4540 if (PyErr_Occurred()) SWIG_fail;
4541 }
4542 Py_INCREF(Py_None); resultobj = Py_None;
4543 return resultobj;
4544 fail:
4545 return NULL;
4546 }
4547
4548
4549 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4550 PyObject *resultobj;
4551 wxBitmap *arg1 = (wxBitmap *) 0 ;
4552 wxRect *arg2 = 0 ;
4553 SwigValueWrapper<wxBitmap > result;
4554 wxRect temp2 ;
4555 PyObject * obj0 = 0 ;
4556 PyObject * obj1 = 0 ;
4557 char *kwnames[] = {
4558 (char *) "self",(char *) "rect", NULL
4559 };
4560
4561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4563 if (SWIG_arg_fail(1)) SWIG_fail;
4564 {
4565 arg2 = &temp2;
4566 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4567 }
4568 {
4569 PyThreadState* __tstate = wxPyBeginAllowThreads();
4570 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4571
4572 wxPyEndAllowThreads(__tstate);
4573 if (PyErr_Occurred()) SWIG_fail;
4574 }
4575 {
4576 wxBitmap * resultptr;
4577 resultptr = new wxBitmap((wxBitmap &)(result));
4578 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4579 }
4580 return resultobj;
4581 fail:
4582 return NULL;
4583 }
4584
4585
4586 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4587 PyObject *resultobj;
4588 wxBitmap *arg1 = (wxBitmap *) 0 ;
4589 wxString *arg2 = 0 ;
4590 wxBitmapType arg3 ;
4591 wxPalette *arg4 = (wxPalette *) NULL ;
4592 bool result;
4593 bool temp2 = false ;
4594 PyObject * obj0 = 0 ;
4595 PyObject * obj1 = 0 ;
4596 PyObject * obj2 = 0 ;
4597 PyObject * obj3 = 0 ;
4598 char *kwnames[] = {
4599 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4600 };
4601
4602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4604 if (SWIG_arg_fail(1)) SWIG_fail;
4605 {
4606 arg2 = wxString_in_helper(obj1);
4607 if (arg2 == NULL) SWIG_fail;
4608 temp2 = true;
4609 }
4610 {
4611 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4612 if (SWIG_arg_fail(3)) SWIG_fail;
4613 }
4614 if (obj3) {
4615 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4616 if (SWIG_arg_fail(4)) SWIG_fail;
4617 }
4618 {
4619 PyThreadState* __tstate = wxPyBeginAllowThreads();
4620 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4621
4622 wxPyEndAllowThreads(__tstate);
4623 if (PyErr_Occurred()) SWIG_fail;
4624 }
4625 {
4626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4627 }
4628 {
4629 if (temp2)
4630 delete arg2;
4631 }
4632 return resultobj;
4633 fail:
4634 {
4635 if (temp2)
4636 delete arg2;
4637 }
4638 return NULL;
4639 }
4640
4641
4642 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4643 PyObject *resultobj;
4644 wxBitmap *arg1 = (wxBitmap *) 0 ;
4645 wxString *arg2 = 0 ;
4646 wxBitmapType arg3 ;
4647 bool result;
4648 bool temp2 = false ;
4649 PyObject * obj0 = 0 ;
4650 PyObject * obj1 = 0 ;
4651 PyObject * obj2 = 0 ;
4652 char *kwnames[] = {
4653 (char *) "self",(char *) "name",(char *) "type", NULL
4654 };
4655
4656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4658 if (SWIG_arg_fail(1)) SWIG_fail;
4659 {
4660 arg2 = wxString_in_helper(obj1);
4661 if (arg2 == NULL) SWIG_fail;
4662 temp2 = true;
4663 }
4664 {
4665 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4666 if (SWIG_arg_fail(3)) SWIG_fail;
4667 }
4668 {
4669 PyThreadState* __tstate = wxPyBeginAllowThreads();
4670 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4671
4672 wxPyEndAllowThreads(__tstate);
4673 if (PyErr_Occurred()) SWIG_fail;
4674 }
4675 {
4676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4677 }
4678 {
4679 if (temp2)
4680 delete arg2;
4681 }
4682 return resultobj;
4683 fail:
4684 {
4685 if (temp2)
4686 delete arg2;
4687 }
4688 return NULL;
4689 }
4690
4691
4692 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4693 PyObject *resultobj;
4694 wxBitmap *arg1 = (wxBitmap *) 0 ;
4695 wxPalette *result;
4696 PyObject * obj0 = 0 ;
4697 char *kwnames[] = {
4698 (char *) "self", NULL
4699 };
4700
4701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4703 if (SWIG_arg_fail(1)) SWIG_fail;
4704 {
4705 PyThreadState* __tstate = wxPyBeginAllowThreads();
4706 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4707
4708 wxPyEndAllowThreads(__tstate);
4709 if (PyErr_Occurred()) SWIG_fail;
4710 }
4711 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4712 return resultobj;
4713 fail:
4714 return NULL;
4715 }
4716
4717
4718 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4719 PyObject *resultobj;
4720 wxBitmap *arg1 = (wxBitmap *) 0 ;
4721 wxIcon *arg2 = 0 ;
4722 bool result;
4723 PyObject * obj0 = 0 ;
4724 PyObject * obj1 = 0 ;
4725 char *kwnames[] = {
4726 (char *) "self",(char *) "icon", NULL
4727 };
4728
4729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4731 if (SWIG_arg_fail(1)) SWIG_fail;
4732 {
4733 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4734 if (SWIG_arg_fail(2)) SWIG_fail;
4735 if (arg2 == NULL) {
4736 SWIG_null_ref("wxIcon");
4737 }
4738 if (SWIG_arg_fail(2)) SWIG_fail;
4739 }
4740 {
4741 PyThreadState* __tstate = wxPyBeginAllowThreads();
4742 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4743
4744 wxPyEndAllowThreads(__tstate);
4745 if (PyErr_Occurred()) SWIG_fail;
4746 }
4747 {
4748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4749 }
4750 return resultobj;
4751 fail:
4752 return NULL;
4753 }
4754
4755
4756 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4757 PyObject *resultobj;
4758 wxBitmap *arg1 = (wxBitmap *) 0 ;
4759 int arg2 ;
4760 PyObject * obj0 = 0 ;
4761 PyObject * obj1 = 0 ;
4762 char *kwnames[] = {
4763 (char *) "self",(char *) "height", NULL
4764 };
4765
4766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4768 if (SWIG_arg_fail(1)) SWIG_fail;
4769 {
4770 arg2 = (int)(SWIG_As_int(obj1));
4771 if (SWIG_arg_fail(2)) SWIG_fail;
4772 }
4773 {
4774 PyThreadState* __tstate = wxPyBeginAllowThreads();
4775 (arg1)->SetHeight(arg2);
4776
4777 wxPyEndAllowThreads(__tstate);
4778 if (PyErr_Occurred()) SWIG_fail;
4779 }
4780 Py_INCREF(Py_None); resultobj = Py_None;
4781 return resultobj;
4782 fail:
4783 return NULL;
4784 }
4785
4786
4787 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4788 PyObject *resultobj;
4789 wxBitmap *arg1 = (wxBitmap *) 0 ;
4790 int arg2 ;
4791 PyObject * obj0 = 0 ;
4792 PyObject * obj1 = 0 ;
4793 char *kwnames[] = {
4794 (char *) "self",(char *) "width", NULL
4795 };
4796
4797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4799 if (SWIG_arg_fail(1)) SWIG_fail;
4800 {
4801 arg2 = (int)(SWIG_As_int(obj1));
4802 if (SWIG_arg_fail(2)) SWIG_fail;
4803 }
4804 {
4805 PyThreadState* __tstate = wxPyBeginAllowThreads();
4806 (arg1)->SetWidth(arg2);
4807
4808 wxPyEndAllowThreads(__tstate);
4809 if (PyErr_Occurred()) SWIG_fail;
4810 }
4811 Py_INCREF(Py_None); resultobj = Py_None;
4812 return resultobj;
4813 fail:
4814 return NULL;
4815 }
4816
4817
4818 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4819 PyObject *resultobj;
4820 wxBitmap *arg1 = (wxBitmap *) 0 ;
4821 int arg2 ;
4822 PyObject * obj0 = 0 ;
4823 PyObject * obj1 = 0 ;
4824 char *kwnames[] = {
4825 (char *) "self",(char *) "depth", NULL
4826 };
4827
4828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4830 if (SWIG_arg_fail(1)) SWIG_fail;
4831 {
4832 arg2 = (int)(SWIG_As_int(obj1));
4833 if (SWIG_arg_fail(2)) SWIG_fail;
4834 }
4835 {
4836 PyThreadState* __tstate = wxPyBeginAllowThreads();
4837 (arg1)->SetDepth(arg2);
4838
4839 wxPyEndAllowThreads(__tstate);
4840 if (PyErr_Occurred()) SWIG_fail;
4841 }
4842 Py_INCREF(Py_None); resultobj = Py_None;
4843 return resultobj;
4844 fail:
4845 return NULL;
4846 }
4847
4848
4849 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4850 PyObject *resultobj;
4851 wxBitmap *arg1 = (wxBitmap *) 0 ;
4852 wxSize *arg2 = 0 ;
4853 wxSize temp2 ;
4854 PyObject * obj0 = 0 ;
4855 PyObject * obj1 = 0 ;
4856 char *kwnames[] = {
4857 (char *) "self",(char *) "size", NULL
4858 };
4859
4860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4862 if (SWIG_arg_fail(1)) SWIG_fail;
4863 {
4864 arg2 = &temp2;
4865 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4866 }
4867 {
4868 PyThreadState* __tstate = wxPyBeginAllowThreads();
4869 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4870
4871 wxPyEndAllowThreads(__tstate);
4872 if (PyErr_Occurred()) SWIG_fail;
4873 }
4874 Py_INCREF(Py_None); resultobj = Py_None;
4875 return resultobj;
4876 fail:
4877 return NULL;
4878 }
4879
4880
4881 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4882 PyObject *resultobj;
4883 wxBitmap *arg1 = (wxBitmap *) 0 ;
4884 wxBitmap *arg2 = (wxBitmap *) 0 ;
4885 bool result;
4886 PyObject * obj0 = 0 ;
4887 PyObject * obj1 = 0 ;
4888 char *kwnames[] = {
4889 (char *) "self",(char *) "other", NULL
4890 };
4891
4892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
4893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4894 if (SWIG_arg_fail(1)) SWIG_fail;
4895 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4896 if (SWIG_arg_fail(2)) SWIG_fail;
4897 {
4898 PyThreadState* __tstate = wxPyBeginAllowThreads();
4899 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
4900
4901 wxPyEndAllowThreads(__tstate);
4902 if (PyErr_Occurred()) SWIG_fail;
4903 }
4904 {
4905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4906 }
4907 return resultobj;
4908 fail:
4909 return NULL;
4910 }
4911
4912
4913 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4914 PyObject *resultobj;
4915 wxBitmap *arg1 = (wxBitmap *) 0 ;
4916 wxBitmap *arg2 = (wxBitmap *) 0 ;
4917 bool result;
4918 PyObject * obj0 = 0 ;
4919 PyObject * obj1 = 0 ;
4920 char *kwnames[] = {
4921 (char *) "self",(char *) "other", NULL
4922 };
4923
4924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
4925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4926 if (SWIG_arg_fail(1)) SWIG_fail;
4927 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4928 if (SWIG_arg_fail(2)) SWIG_fail;
4929 {
4930 PyThreadState* __tstate = wxPyBeginAllowThreads();
4931 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
4932
4933 wxPyEndAllowThreads(__tstate);
4934 if (PyErr_Occurred()) SWIG_fail;
4935 }
4936 {
4937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4938 }
4939 return resultobj;
4940 fail:
4941 return NULL;
4942 }
4943
4944
4945 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
4946 PyObject *obj;
4947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4948 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
4949 Py_INCREF(obj);
4950 return Py_BuildValue((char *)"");
4951 }
4952 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
4953 PyObject *resultobj;
4954 wxBitmap *arg1 = 0 ;
4955 wxColour const &arg2_defvalue = wxNullColour ;
4956 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
4957 wxMask *result;
4958 wxColour temp2 ;
4959 PyObject * obj0 = 0 ;
4960 PyObject * obj1 = 0 ;
4961 char *kwnames[] = {
4962 (char *) "bitmap",(char *) "colour", NULL
4963 };
4964
4965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
4966 {
4967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4968 if (SWIG_arg_fail(1)) SWIG_fail;
4969 if (arg1 == NULL) {
4970 SWIG_null_ref("wxBitmap");
4971 }
4972 if (SWIG_arg_fail(1)) SWIG_fail;
4973 }
4974 if (obj1) {
4975 {
4976 arg2 = &temp2;
4977 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4978 }
4979 }
4980 {
4981 if (!wxPyCheckForApp()) SWIG_fail;
4982 PyThreadState* __tstate = wxPyBeginAllowThreads();
4983 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
4984
4985 wxPyEndAllowThreads(__tstate);
4986 if (PyErr_Occurred()) SWIG_fail;
4987 }
4988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
4989 return resultobj;
4990 fail:
4991 return NULL;
4992 }
4993
4994
4995 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
4996 PyObject *obj;
4997 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4998 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
4999 Py_INCREF(obj);
5000 return Py_BuildValue((char *)"");
5001 }
5002 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5003 PyObject *resultobj;
5004 wxString *arg1 = 0 ;
5005 wxBitmapType arg2 ;
5006 int arg3 = (int) -1 ;
5007 int arg4 = (int) -1 ;
5008 wxIcon *result;
5009 bool temp1 = false ;
5010 PyObject * obj0 = 0 ;
5011 PyObject * obj1 = 0 ;
5012 PyObject * obj2 = 0 ;
5013 PyObject * obj3 = 0 ;
5014 char *kwnames[] = {
5015 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
5016 };
5017
5018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5019 {
5020 arg1 = wxString_in_helper(obj0);
5021 if (arg1 == NULL) SWIG_fail;
5022 temp1 = true;
5023 }
5024 {
5025 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
5026 if (SWIG_arg_fail(2)) SWIG_fail;
5027 }
5028 if (obj2) {
5029 {
5030 arg3 = (int)(SWIG_As_int(obj2));
5031 if (SWIG_arg_fail(3)) SWIG_fail;
5032 }
5033 }
5034 if (obj3) {
5035 {
5036 arg4 = (int)(SWIG_As_int(obj3));
5037 if (SWIG_arg_fail(4)) SWIG_fail;
5038 }
5039 }
5040 {
5041 if (!wxPyCheckForApp()) SWIG_fail;
5042 PyThreadState* __tstate = wxPyBeginAllowThreads();
5043 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
5044
5045 wxPyEndAllowThreads(__tstate);
5046 if (PyErr_Occurred()) SWIG_fail;
5047 }
5048 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5049 {
5050 if (temp1)
5051 delete arg1;
5052 }
5053 return resultobj;
5054 fail:
5055 {
5056 if (temp1)
5057 delete arg1;
5058 }
5059 return NULL;
5060 }
5061
5062
5063 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5064 PyObject *resultobj;
5065 wxIcon *arg1 = (wxIcon *) 0 ;
5066 PyObject * obj0 = 0 ;
5067 char *kwnames[] = {
5068 (char *) "self", NULL
5069 };
5070
5071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
5072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5073 if (SWIG_arg_fail(1)) SWIG_fail;
5074 {
5075 PyThreadState* __tstate = wxPyBeginAllowThreads();
5076 delete arg1;
5077
5078 wxPyEndAllowThreads(__tstate);
5079 if (PyErr_Occurred()) SWIG_fail;
5080 }
5081 Py_INCREF(Py_None); resultobj = Py_None;
5082 return resultobj;
5083 fail:
5084 return NULL;
5085 }
5086
5087
5088 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5089 PyObject *resultobj;
5090 wxIcon *result;
5091 char *kwnames[] = {
5092 NULL
5093 };
5094
5095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5096 {
5097 if (!wxPyCheckForApp()) SWIG_fail;
5098 PyThreadState* __tstate = wxPyBeginAllowThreads();
5099 result = (wxIcon *)new wxIcon();
5100
5101 wxPyEndAllowThreads(__tstate);
5102 if (PyErr_Occurred()) SWIG_fail;
5103 }
5104 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5105 return resultobj;
5106 fail:
5107 return NULL;
5108 }
5109
5110
5111 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5112 PyObject *resultobj;
5113 wxIconLocation *arg1 = 0 ;
5114 wxIcon *result;
5115 PyObject * obj0 = 0 ;
5116 char *kwnames[] = {
5117 (char *) "loc", NULL
5118 };
5119
5120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5121 {
5122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5123 if (SWIG_arg_fail(1)) SWIG_fail;
5124 if (arg1 == NULL) {
5125 SWIG_null_ref("wxIconLocation");
5126 }
5127 if (SWIG_arg_fail(1)) SWIG_fail;
5128 }
5129 {
5130 if (!wxPyCheckForApp()) SWIG_fail;
5131 PyThreadState* __tstate = wxPyBeginAllowThreads();
5132 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5133
5134 wxPyEndAllowThreads(__tstate);
5135 if (PyErr_Occurred()) SWIG_fail;
5136 }
5137 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5138 return resultobj;
5139 fail:
5140 return NULL;
5141 }
5142
5143
5144 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5145 PyObject *resultobj;
5146 wxBitmap *arg1 = 0 ;
5147 wxIcon *result;
5148 PyObject * obj0 = 0 ;
5149 char *kwnames[] = {
5150 (char *) "bmp", NULL
5151 };
5152
5153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5154 {
5155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5156 if (SWIG_arg_fail(1)) SWIG_fail;
5157 if (arg1 == NULL) {
5158 SWIG_null_ref("wxBitmap");
5159 }
5160 if (SWIG_arg_fail(1)) SWIG_fail;
5161 }
5162 {
5163 if (!wxPyCheckForApp()) SWIG_fail;
5164 PyThreadState* __tstate = wxPyBeginAllowThreads();
5165 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5166
5167 wxPyEndAllowThreads(__tstate);
5168 if (PyErr_Occurred()) SWIG_fail;
5169 }
5170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5171 return resultobj;
5172 fail:
5173 return NULL;
5174 }
5175
5176
5177 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5178 PyObject *resultobj;
5179 PyObject *arg1 = (PyObject *) 0 ;
5180 wxIcon *result;
5181 PyObject * obj0 = 0 ;
5182 char *kwnames[] = {
5183 (char *) "listOfStrings", NULL
5184 };
5185
5186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5187 arg1 = obj0;
5188 {
5189 if (!wxPyCheckForApp()) SWIG_fail;
5190 PyThreadState* __tstate = wxPyBeginAllowThreads();
5191 result = (wxIcon *)new_wxIcon(arg1);
5192
5193 wxPyEndAllowThreads(__tstate);
5194 if (PyErr_Occurred()) SWIG_fail;
5195 }
5196 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5197 return resultobj;
5198 fail:
5199 return NULL;
5200 }
5201
5202
5203 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5204 PyObject *resultobj;
5205 wxIcon *arg1 = (wxIcon *) 0 ;
5206 bool result;
5207 PyObject * obj0 = 0 ;
5208 char *kwnames[] = {
5209 (char *) "self", NULL
5210 };
5211
5212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5214 if (SWIG_arg_fail(1)) SWIG_fail;
5215 {
5216 PyThreadState* __tstate = wxPyBeginAllowThreads();
5217 result = (bool)(arg1)->Ok();
5218
5219 wxPyEndAllowThreads(__tstate);
5220 if (PyErr_Occurred()) SWIG_fail;
5221 }
5222 {
5223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5224 }
5225 return resultobj;
5226 fail:
5227 return NULL;
5228 }
5229
5230
5231 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5232 PyObject *resultobj;
5233 wxIcon *arg1 = (wxIcon *) 0 ;
5234 int result;
5235 PyObject * obj0 = 0 ;
5236 char *kwnames[] = {
5237 (char *) "self", NULL
5238 };
5239
5240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5242 if (SWIG_arg_fail(1)) SWIG_fail;
5243 {
5244 PyThreadState* __tstate = wxPyBeginAllowThreads();
5245 result = (int)(arg1)->GetWidth();
5246
5247 wxPyEndAllowThreads(__tstate);
5248 if (PyErr_Occurred()) SWIG_fail;
5249 }
5250 {
5251 resultobj = SWIG_From_int((int)(result));
5252 }
5253 return resultobj;
5254 fail:
5255 return NULL;
5256 }
5257
5258
5259 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5260 PyObject *resultobj;
5261 wxIcon *arg1 = (wxIcon *) 0 ;
5262 int result;
5263 PyObject * obj0 = 0 ;
5264 char *kwnames[] = {
5265 (char *) "self", NULL
5266 };
5267
5268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5270 if (SWIG_arg_fail(1)) SWIG_fail;
5271 {
5272 PyThreadState* __tstate = wxPyBeginAllowThreads();
5273 result = (int)(arg1)->GetHeight();
5274
5275 wxPyEndAllowThreads(__tstate);
5276 if (PyErr_Occurred()) SWIG_fail;
5277 }
5278 {
5279 resultobj = SWIG_From_int((int)(result));
5280 }
5281 return resultobj;
5282 fail:
5283 return NULL;
5284 }
5285
5286
5287 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5288 PyObject *resultobj;
5289 wxIcon *arg1 = (wxIcon *) 0 ;
5290 int result;
5291 PyObject * obj0 = 0 ;
5292 char *kwnames[] = {
5293 (char *) "self", NULL
5294 };
5295
5296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5298 if (SWIG_arg_fail(1)) SWIG_fail;
5299 {
5300 PyThreadState* __tstate = wxPyBeginAllowThreads();
5301 result = (int)(arg1)->GetDepth();
5302
5303 wxPyEndAllowThreads(__tstate);
5304 if (PyErr_Occurred()) SWIG_fail;
5305 }
5306 {
5307 resultobj = SWIG_From_int((int)(result));
5308 }
5309 return resultobj;
5310 fail:
5311 return NULL;
5312 }
5313
5314
5315 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5316 PyObject *resultobj;
5317 wxIcon *arg1 = (wxIcon *) 0 ;
5318 int arg2 ;
5319 PyObject * obj0 = 0 ;
5320 PyObject * obj1 = 0 ;
5321 char *kwnames[] = {
5322 (char *) "self",(char *) "w", NULL
5323 };
5324
5325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5327 if (SWIG_arg_fail(1)) SWIG_fail;
5328 {
5329 arg2 = (int)(SWIG_As_int(obj1));
5330 if (SWIG_arg_fail(2)) SWIG_fail;
5331 }
5332 {
5333 PyThreadState* __tstate = wxPyBeginAllowThreads();
5334 (arg1)->SetWidth(arg2);
5335
5336 wxPyEndAllowThreads(__tstate);
5337 if (PyErr_Occurred()) SWIG_fail;
5338 }
5339 Py_INCREF(Py_None); resultobj = Py_None;
5340 return resultobj;
5341 fail:
5342 return NULL;
5343 }
5344
5345
5346 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5347 PyObject *resultobj;
5348 wxIcon *arg1 = (wxIcon *) 0 ;
5349 int arg2 ;
5350 PyObject * obj0 = 0 ;
5351 PyObject * obj1 = 0 ;
5352 char *kwnames[] = {
5353 (char *) "self",(char *) "h", NULL
5354 };
5355
5356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5358 if (SWIG_arg_fail(1)) SWIG_fail;
5359 {
5360 arg2 = (int)(SWIG_As_int(obj1));
5361 if (SWIG_arg_fail(2)) SWIG_fail;
5362 }
5363 {
5364 PyThreadState* __tstate = wxPyBeginAllowThreads();
5365 (arg1)->SetHeight(arg2);
5366
5367 wxPyEndAllowThreads(__tstate);
5368 if (PyErr_Occurred()) SWIG_fail;
5369 }
5370 Py_INCREF(Py_None); resultobj = Py_None;
5371 return resultobj;
5372 fail:
5373 return NULL;
5374 }
5375
5376
5377 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5378 PyObject *resultobj;
5379 wxIcon *arg1 = (wxIcon *) 0 ;
5380 int arg2 ;
5381 PyObject * obj0 = 0 ;
5382 PyObject * obj1 = 0 ;
5383 char *kwnames[] = {
5384 (char *) "self",(char *) "d", NULL
5385 };
5386
5387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5389 if (SWIG_arg_fail(1)) SWIG_fail;
5390 {
5391 arg2 = (int)(SWIG_As_int(obj1));
5392 if (SWIG_arg_fail(2)) SWIG_fail;
5393 }
5394 {
5395 PyThreadState* __tstate = wxPyBeginAllowThreads();
5396 (arg1)->SetDepth(arg2);
5397
5398 wxPyEndAllowThreads(__tstate);
5399 if (PyErr_Occurred()) SWIG_fail;
5400 }
5401 Py_INCREF(Py_None); resultobj = Py_None;
5402 return resultobj;
5403 fail:
5404 return NULL;
5405 }
5406
5407
5408 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5409 PyObject *resultobj;
5410 wxIcon *arg1 = (wxIcon *) 0 ;
5411 wxBitmap *arg2 = 0 ;
5412 PyObject * obj0 = 0 ;
5413 PyObject * obj1 = 0 ;
5414 char *kwnames[] = {
5415 (char *) "self",(char *) "bmp", NULL
5416 };
5417
5418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5420 if (SWIG_arg_fail(1)) SWIG_fail;
5421 {
5422 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5423 if (SWIG_arg_fail(2)) SWIG_fail;
5424 if (arg2 == NULL) {
5425 SWIG_null_ref("wxBitmap");
5426 }
5427 if (SWIG_arg_fail(2)) SWIG_fail;
5428 }
5429 {
5430 PyThreadState* __tstate = wxPyBeginAllowThreads();
5431 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5432
5433 wxPyEndAllowThreads(__tstate);
5434 if (PyErr_Occurred()) SWIG_fail;
5435 }
5436 Py_INCREF(Py_None); resultobj = Py_None;
5437 return resultobj;
5438 fail:
5439 return NULL;
5440 }
5441
5442
5443 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5444 PyObject *obj;
5445 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5446 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5447 Py_INCREF(obj);
5448 return Py_BuildValue((char *)"");
5449 }
5450 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5451 PyObject *resultobj;
5452 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5453 int arg2 = (int) 0 ;
5454 wxIconLocation *result;
5455 bool temp1 = false ;
5456 PyObject * obj0 = 0 ;
5457 PyObject * obj1 = 0 ;
5458 char *kwnames[] = {
5459 (char *) "filename",(char *) "num", NULL
5460 };
5461
5462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5463 if (obj0) {
5464 {
5465 arg1 = wxString_in_helper(obj0);
5466 if (arg1 == NULL) SWIG_fail;
5467 temp1 = true;
5468 }
5469 }
5470 if (obj1) {
5471 {
5472 arg2 = (int)(SWIG_As_int(obj1));
5473 if (SWIG_arg_fail(2)) SWIG_fail;
5474 }
5475 }
5476 {
5477 PyThreadState* __tstate = wxPyBeginAllowThreads();
5478 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5479
5480 wxPyEndAllowThreads(__tstate);
5481 if (PyErr_Occurred()) SWIG_fail;
5482 }
5483 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5484 {
5485 if (temp1)
5486 delete arg1;
5487 }
5488 return resultobj;
5489 fail:
5490 {
5491 if (temp1)
5492 delete arg1;
5493 }
5494 return NULL;
5495 }
5496
5497
5498 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5499 PyObject *resultobj;
5500 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5501 PyObject * obj0 = 0 ;
5502 char *kwnames[] = {
5503 (char *) "self", NULL
5504 };
5505
5506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5508 if (SWIG_arg_fail(1)) SWIG_fail;
5509 {
5510 PyThreadState* __tstate = wxPyBeginAllowThreads();
5511 delete arg1;
5512
5513 wxPyEndAllowThreads(__tstate);
5514 if (PyErr_Occurred()) SWIG_fail;
5515 }
5516 Py_INCREF(Py_None); resultobj = Py_None;
5517 return resultobj;
5518 fail:
5519 return NULL;
5520 }
5521
5522
5523 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5524 PyObject *resultobj;
5525 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5526 bool result;
5527 PyObject * obj0 = 0 ;
5528 char *kwnames[] = {
5529 (char *) "self", NULL
5530 };
5531
5532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5534 if (SWIG_arg_fail(1)) SWIG_fail;
5535 {
5536 PyThreadState* __tstate = wxPyBeginAllowThreads();
5537 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5538
5539 wxPyEndAllowThreads(__tstate);
5540 if (PyErr_Occurred()) SWIG_fail;
5541 }
5542 {
5543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5544 }
5545 return resultobj;
5546 fail:
5547 return NULL;
5548 }
5549
5550
5551 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5552 PyObject *resultobj;
5553 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5554 wxString *arg2 = 0 ;
5555 bool temp2 = false ;
5556 PyObject * obj0 = 0 ;
5557 PyObject * obj1 = 0 ;
5558 char *kwnames[] = {
5559 (char *) "self",(char *) "filename", NULL
5560 };
5561
5562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5564 if (SWIG_arg_fail(1)) SWIG_fail;
5565 {
5566 arg2 = wxString_in_helper(obj1);
5567 if (arg2 == NULL) SWIG_fail;
5568 temp2 = true;
5569 }
5570 {
5571 PyThreadState* __tstate = wxPyBeginAllowThreads();
5572 (arg1)->SetFileName((wxString const &)*arg2);
5573
5574 wxPyEndAllowThreads(__tstate);
5575 if (PyErr_Occurred()) SWIG_fail;
5576 }
5577 Py_INCREF(Py_None); resultobj = Py_None;
5578 {
5579 if (temp2)
5580 delete arg2;
5581 }
5582 return resultobj;
5583 fail:
5584 {
5585 if (temp2)
5586 delete arg2;
5587 }
5588 return NULL;
5589 }
5590
5591
5592 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5593 PyObject *resultobj;
5594 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5595 wxString *result;
5596 PyObject * obj0 = 0 ;
5597 char *kwnames[] = {
5598 (char *) "self", NULL
5599 };
5600
5601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5603 if (SWIG_arg_fail(1)) SWIG_fail;
5604 {
5605 PyThreadState* __tstate = wxPyBeginAllowThreads();
5606 {
5607 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5608 result = (wxString *) &_result_ref;
5609 }
5610
5611 wxPyEndAllowThreads(__tstate);
5612 if (PyErr_Occurred()) SWIG_fail;
5613 }
5614 {
5615 #if wxUSE_UNICODE
5616 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5617 #else
5618 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5619 #endif
5620 }
5621 return resultobj;
5622 fail:
5623 return NULL;
5624 }
5625
5626
5627 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5628 PyObject *resultobj;
5629 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5630 int arg2 ;
5631 PyObject * obj0 = 0 ;
5632 PyObject * obj1 = 0 ;
5633 char *kwnames[] = {
5634 (char *) "self",(char *) "num", NULL
5635 };
5636
5637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5639 if (SWIG_arg_fail(1)) SWIG_fail;
5640 {
5641 arg2 = (int)(SWIG_As_int(obj1));
5642 if (SWIG_arg_fail(2)) SWIG_fail;
5643 }
5644 {
5645 PyThreadState* __tstate = wxPyBeginAllowThreads();
5646 wxIconLocation_SetIndex(arg1,arg2);
5647
5648 wxPyEndAllowThreads(__tstate);
5649 if (PyErr_Occurred()) SWIG_fail;
5650 }
5651 Py_INCREF(Py_None); resultobj = Py_None;
5652 return resultobj;
5653 fail:
5654 return NULL;
5655 }
5656
5657
5658 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5659 PyObject *resultobj;
5660 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5661 int result;
5662 PyObject * obj0 = 0 ;
5663 char *kwnames[] = {
5664 (char *) "self", NULL
5665 };
5666
5667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5669 if (SWIG_arg_fail(1)) SWIG_fail;
5670 {
5671 PyThreadState* __tstate = wxPyBeginAllowThreads();
5672 result = (int)wxIconLocation_GetIndex(arg1);
5673
5674 wxPyEndAllowThreads(__tstate);
5675 if (PyErr_Occurred()) SWIG_fail;
5676 }
5677 {
5678 resultobj = SWIG_From_int((int)(result));
5679 }
5680 return resultobj;
5681 fail:
5682 return NULL;
5683 }
5684
5685
5686 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5687 PyObject *obj;
5688 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5689 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5690 Py_INCREF(obj);
5691 return Py_BuildValue((char *)"");
5692 }
5693 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5694 PyObject *resultobj;
5695 wxIconBundle *result;
5696 char *kwnames[] = {
5697 NULL
5698 };
5699
5700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5701 {
5702 PyThreadState* __tstate = wxPyBeginAllowThreads();
5703 result = (wxIconBundle *)new wxIconBundle();
5704
5705 wxPyEndAllowThreads(__tstate);
5706 if (PyErr_Occurred()) SWIG_fail;
5707 }
5708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5709 return resultobj;
5710 fail:
5711 return NULL;
5712 }
5713
5714
5715 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5716 PyObject *resultobj;
5717 wxString *arg1 = 0 ;
5718 long arg2 ;
5719 wxIconBundle *result;
5720 bool temp1 = false ;
5721 PyObject * obj0 = 0 ;
5722 PyObject * obj1 = 0 ;
5723 char *kwnames[] = {
5724 (char *) "file",(char *) "type", NULL
5725 };
5726
5727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
5728 {
5729 arg1 = wxString_in_helper(obj0);
5730 if (arg1 == NULL) SWIG_fail;
5731 temp1 = true;
5732 }
5733 {
5734 arg2 = (long)(SWIG_As_long(obj1));
5735 if (SWIG_arg_fail(2)) SWIG_fail;
5736 }
5737 {
5738 PyThreadState* __tstate = wxPyBeginAllowThreads();
5739 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
5740
5741 wxPyEndAllowThreads(__tstate);
5742 if (PyErr_Occurred()) SWIG_fail;
5743 }
5744 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5745 {
5746 if (temp1)
5747 delete arg1;
5748 }
5749 return resultobj;
5750 fail:
5751 {
5752 if (temp1)
5753 delete arg1;
5754 }
5755 return NULL;
5756 }
5757
5758
5759 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5760 PyObject *resultobj;
5761 wxIcon *arg1 = 0 ;
5762 wxIconBundle *result;
5763 PyObject * obj0 = 0 ;
5764 char *kwnames[] = {
5765 (char *) "icon", NULL
5766 };
5767
5768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
5769 {
5770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5771 if (SWIG_arg_fail(1)) SWIG_fail;
5772 if (arg1 == NULL) {
5773 SWIG_null_ref("wxIcon");
5774 }
5775 if (SWIG_arg_fail(1)) SWIG_fail;
5776 }
5777 {
5778 PyThreadState* __tstate = wxPyBeginAllowThreads();
5779 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
5780
5781 wxPyEndAllowThreads(__tstate);
5782 if (PyErr_Occurred()) SWIG_fail;
5783 }
5784 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5785 return resultobj;
5786 fail:
5787 return NULL;
5788 }
5789
5790
5791 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5792 PyObject *resultobj;
5793 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5794 PyObject * obj0 = 0 ;
5795 char *kwnames[] = {
5796 (char *) "self", NULL
5797 };
5798
5799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
5800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5801 if (SWIG_arg_fail(1)) SWIG_fail;
5802 {
5803 PyThreadState* __tstate = wxPyBeginAllowThreads();
5804 delete arg1;
5805
5806 wxPyEndAllowThreads(__tstate);
5807 if (PyErr_Occurred()) SWIG_fail;
5808 }
5809 Py_INCREF(Py_None); resultobj = Py_None;
5810 return resultobj;
5811 fail:
5812 return NULL;
5813 }
5814
5815
5816 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5817 PyObject *resultobj;
5818 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5819 wxIcon *arg2 = 0 ;
5820 PyObject * obj0 = 0 ;
5821 PyObject * obj1 = 0 ;
5822 char *kwnames[] = {
5823 (char *) "self",(char *) "icon", NULL
5824 };
5825
5826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
5827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5828 if (SWIG_arg_fail(1)) SWIG_fail;
5829 {
5830 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5831 if (SWIG_arg_fail(2)) SWIG_fail;
5832 if (arg2 == NULL) {
5833 SWIG_null_ref("wxIcon");
5834 }
5835 if (SWIG_arg_fail(2)) SWIG_fail;
5836 }
5837 {
5838 PyThreadState* __tstate = wxPyBeginAllowThreads();
5839 (arg1)->AddIcon((wxIcon const &)*arg2);
5840
5841 wxPyEndAllowThreads(__tstate);
5842 if (PyErr_Occurred()) SWIG_fail;
5843 }
5844 Py_INCREF(Py_None); resultobj = Py_None;
5845 return resultobj;
5846 fail:
5847 return NULL;
5848 }
5849
5850
5851 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5852 PyObject *resultobj;
5853 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5854 wxString *arg2 = 0 ;
5855 long arg3 ;
5856 bool temp2 = false ;
5857 PyObject * obj0 = 0 ;
5858 PyObject * obj1 = 0 ;
5859 PyObject * obj2 = 0 ;
5860 char *kwnames[] = {
5861 (char *) "self",(char *) "file",(char *) "type", NULL
5862 };
5863
5864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5866 if (SWIG_arg_fail(1)) SWIG_fail;
5867 {
5868 arg2 = wxString_in_helper(obj1);
5869 if (arg2 == NULL) SWIG_fail;
5870 temp2 = true;
5871 }
5872 {
5873 arg3 = (long)(SWIG_As_long(obj2));
5874 if (SWIG_arg_fail(3)) SWIG_fail;
5875 }
5876 {
5877 PyThreadState* __tstate = wxPyBeginAllowThreads();
5878 (arg1)->AddIcon((wxString const &)*arg2,arg3);
5879
5880 wxPyEndAllowThreads(__tstate);
5881 if (PyErr_Occurred()) SWIG_fail;
5882 }
5883 Py_INCREF(Py_None); resultobj = Py_None;
5884 {
5885 if (temp2)
5886 delete arg2;
5887 }
5888 return resultobj;
5889 fail:
5890 {
5891 if (temp2)
5892 delete arg2;
5893 }
5894 return NULL;
5895 }
5896
5897
5898 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5899 PyObject *resultobj;
5900 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5901 wxSize *arg2 = 0 ;
5902 wxIcon *result;
5903 wxSize temp2 ;
5904 PyObject * obj0 = 0 ;
5905 PyObject * obj1 = 0 ;
5906 char *kwnames[] = {
5907 (char *) "self",(char *) "size", NULL
5908 };
5909
5910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
5911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5912 if (SWIG_arg_fail(1)) SWIG_fail;
5913 {
5914 arg2 = &temp2;
5915 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5916 }
5917 {
5918 PyThreadState* __tstate = wxPyBeginAllowThreads();
5919 {
5920 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
5921 result = (wxIcon *) &_result_ref;
5922 }
5923
5924 wxPyEndAllowThreads(__tstate);
5925 if (PyErr_Occurred()) SWIG_fail;
5926 }
5927 {
5928 wxIcon* resultptr = new wxIcon(*result);
5929 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
5930 }
5931 return resultobj;
5932 fail:
5933 return NULL;
5934 }
5935
5936
5937 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
5938 PyObject *obj;
5939 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5940 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
5941 Py_INCREF(obj);
5942 return Py_BuildValue((char *)"");
5943 }
5944 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5945 PyObject *resultobj;
5946 wxString *arg1 = 0 ;
5947 long arg2 ;
5948 int arg3 = (int) 0 ;
5949 int arg4 = (int) 0 ;
5950 wxCursor *result;
5951 bool temp1 = false ;
5952 PyObject * obj0 = 0 ;
5953 PyObject * obj1 = 0 ;
5954 PyObject * obj2 = 0 ;
5955 PyObject * obj3 = 0 ;
5956 char *kwnames[] = {
5957 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
5958 };
5959
5960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5961 {
5962 arg1 = wxString_in_helper(obj0);
5963 if (arg1 == NULL) SWIG_fail;
5964 temp1 = true;
5965 }
5966 {
5967 arg2 = (long)(SWIG_As_long(obj1));
5968 if (SWIG_arg_fail(2)) SWIG_fail;
5969 }
5970 if (obj2) {
5971 {
5972 arg3 = (int)(SWIG_As_int(obj2));
5973 if (SWIG_arg_fail(3)) SWIG_fail;
5974 }
5975 }
5976 if (obj3) {
5977 {
5978 arg4 = (int)(SWIG_As_int(obj3));
5979 if (SWIG_arg_fail(4)) SWIG_fail;
5980 }
5981 }
5982 {
5983 if (!wxPyCheckForApp()) SWIG_fail;
5984 PyThreadState* __tstate = wxPyBeginAllowThreads();
5985 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
5986
5987 wxPyEndAllowThreads(__tstate);
5988 if (PyErr_Occurred()) SWIG_fail;
5989 }
5990 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
5991 {
5992 if (temp1)
5993 delete arg1;
5994 }
5995 return resultobj;
5996 fail:
5997 {
5998 if (temp1)
5999 delete arg1;
6000 }
6001 return NULL;
6002 }
6003
6004
6005 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6006 PyObject *resultobj;
6007 wxCursor *arg1 = (wxCursor *) 0 ;
6008 PyObject * obj0 = 0 ;
6009 char *kwnames[] = {
6010 (char *) "self", NULL
6011 };
6012
6013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
6014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6015 if (SWIG_arg_fail(1)) SWIG_fail;
6016 {
6017 PyThreadState* __tstate = wxPyBeginAllowThreads();
6018 delete arg1;
6019
6020 wxPyEndAllowThreads(__tstate);
6021 if (PyErr_Occurred()) SWIG_fail;
6022 }
6023 Py_INCREF(Py_None); resultobj = Py_None;
6024 return resultobj;
6025 fail:
6026 return NULL;
6027 }
6028
6029
6030 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6031 PyObject *resultobj;
6032 int arg1 ;
6033 wxCursor *result;
6034 PyObject * obj0 = 0 ;
6035 char *kwnames[] = {
6036 (char *) "id", NULL
6037 };
6038
6039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
6040 {
6041 arg1 = (int)(SWIG_As_int(obj0));
6042 if (SWIG_arg_fail(1)) SWIG_fail;
6043 }
6044 {
6045 if (!wxPyCheckForApp()) SWIG_fail;
6046 PyThreadState* __tstate = wxPyBeginAllowThreads();
6047 result = (wxCursor *)new wxCursor(arg1);
6048
6049 wxPyEndAllowThreads(__tstate);
6050 if (PyErr_Occurred()) SWIG_fail;
6051 }
6052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6053 return resultobj;
6054 fail:
6055 return NULL;
6056 }
6057
6058
6059 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6060 PyObject *resultobj;
6061 wxImage *arg1 = 0 ;
6062 wxCursor *result;
6063 PyObject * obj0 = 0 ;
6064 char *kwnames[] = {
6065 (char *) "image", NULL
6066 };
6067
6068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6069 {
6070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6071 if (SWIG_arg_fail(1)) SWIG_fail;
6072 if (arg1 == NULL) {
6073 SWIG_null_ref("wxImage");
6074 }
6075 if (SWIG_arg_fail(1)) SWIG_fail;
6076 }
6077 {
6078 if (!wxPyCheckForApp()) SWIG_fail;
6079 PyThreadState* __tstate = wxPyBeginAllowThreads();
6080 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6081
6082 wxPyEndAllowThreads(__tstate);
6083 if (PyErr_Occurred()) SWIG_fail;
6084 }
6085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6086 return resultobj;
6087 fail:
6088 return NULL;
6089 }
6090
6091
6092 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6093 PyObject *resultobj;
6094 wxCursor *arg1 = (wxCursor *) 0 ;
6095 bool result;
6096 PyObject * obj0 = 0 ;
6097 char *kwnames[] = {
6098 (char *) "self", NULL
6099 };
6100
6101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6103 if (SWIG_arg_fail(1)) SWIG_fail;
6104 {
6105 PyThreadState* __tstate = wxPyBeginAllowThreads();
6106 result = (bool)(arg1)->Ok();
6107
6108 wxPyEndAllowThreads(__tstate);
6109 if (PyErr_Occurred()) SWIG_fail;
6110 }
6111 {
6112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6113 }
6114 return resultobj;
6115 fail:
6116 return NULL;
6117 }
6118
6119
6120 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6121 PyObject *obj;
6122 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6123 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6124 Py_INCREF(obj);
6125 return Py_BuildValue((char *)"");
6126 }
6127 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6128 PyObject *resultobj;
6129 int arg1 = (int) 0 ;
6130 int arg2 = (int) 0 ;
6131 int arg3 = (int) 0 ;
6132 int arg4 = (int) 0 ;
6133 wxRegion *result;
6134 PyObject * obj0 = 0 ;
6135 PyObject * obj1 = 0 ;
6136 PyObject * obj2 = 0 ;
6137 PyObject * obj3 = 0 ;
6138 char *kwnames[] = {
6139 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6140 };
6141
6142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6143 if (obj0) {
6144 {
6145 arg1 = (int)(SWIG_As_int(obj0));
6146 if (SWIG_arg_fail(1)) SWIG_fail;
6147 }
6148 }
6149 if (obj1) {
6150 {
6151 arg2 = (int)(SWIG_As_int(obj1));
6152 if (SWIG_arg_fail(2)) SWIG_fail;
6153 }
6154 }
6155 if (obj2) {
6156 {
6157 arg3 = (int)(SWIG_As_int(obj2));
6158 if (SWIG_arg_fail(3)) SWIG_fail;
6159 }
6160 }
6161 if (obj3) {
6162 {
6163 arg4 = (int)(SWIG_As_int(obj3));
6164 if (SWIG_arg_fail(4)) SWIG_fail;
6165 }
6166 }
6167 {
6168 if (!wxPyCheckForApp()) SWIG_fail;
6169 PyThreadState* __tstate = wxPyBeginAllowThreads();
6170 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6171
6172 wxPyEndAllowThreads(__tstate);
6173 if (PyErr_Occurred()) SWIG_fail;
6174 }
6175 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6176 return resultobj;
6177 fail:
6178 return NULL;
6179 }
6180
6181
6182 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6183 PyObject *resultobj;
6184 wxBitmap *arg1 = 0 ;
6185 wxRegion *result;
6186 PyObject * obj0 = 0 ;
6187 char *kwnames[] = {
6188 (char *) "bmp", NULL
6189 };
6190
6191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6192 {
6193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6194 if (SWIG_arg_fail(1)) SWIG_fail;
6195 if (arg1 == NULL) {
6196 SWIG_null_ref("wxBitmap");
6197 }
6198 if (SWIG_arg_fail(1)) SWIG_fail;
6199 }
6200 {
6201 if (!wxPyCheckForApp()) SWIG_fail;
6202 PyThreadState* __tstate = wxPyBeginAllowThreads();
6203 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6204
6205 wxPyEndAllowThreads(__tstate);
6206 if (PyErr_Occurred()) SWIG_fail;
6207 }
6208 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6209 return resultobj;
6210 fail:
6211 return NULL;
6212 }
6213
6214
6215 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6216 PyObject *resultobj;
6217 wxBitmap *arg1 = 0 ;
6218 wxColour *arg2 = 0 ;
6219 int arg3 = (int) 0 ;
6220 wxRegion *result;
6221 wxColour temp2 ;
6222 PyObject * obj0 = 0 ;
6223 PyObject * obj1 = 0 ;
6224 PyObject * obj2 = 0 ;
6225 char *kwnames[] = {
6226 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6227 };
6228
6229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6230 {
6231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6232 if (SWIG_arg_fail(1)) SWIG_fail;
6233 if (arg1 == NULL) {
6234 SWIG_null_ref("wxBitmap");
6235 }
6236 if (SWIG_arg_fail(1)) SWIG_fail;
6237 }
6238 {
6239 arg2 = &temp2;
6240 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6241 }
6242 if (obj2) {
6243 {
6244 arg3 = (int)(SWIG_As_int(obj2));
6245 if (SWIG_arg_fail(3)) SWIG_fail;
6246 }
6247 }
6248 {
6249 if (!wxPyCheckForApp()) SWIG_fail;
6250 PyThreadState* __tstate = wxPyBeginAllowThreads();
6251 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6252
6253 wxPyEndAllowThreads(__tstate);
6254 if (PyErr_Occurred()) SWIG_fail;
6255 }
6256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6257 return resultobj;
6258 fail:
6259 return NULL;
6260 }
6261
6262
6263 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6264 PyObject *resultobj;
6265 int arg1 ;
6266 wxPoint *arg2 = (wxPoint *) 0 ;
6267 int arg3 = (int) wxWINDING_RULE ;
6268 wxRegion *result;
6269 PyObject * obj0 = 0 ;
6270 PyObject * obj1 = 0 ;
6271 char *kwnames[] = {
6272 (char *) "points",(char *) "fillStyle", NULL
6273 };
6274
6275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6276 {
6277 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6278 if (arg2 == NULL) SWIG_fail;
6279 }
6280 if (obj1) {
6281 {
6282 arg3 = (int)(SWIG_As_int(obj1));
6283 if (SWIG_arg_fail(3)) SWIG_fail;
6284 }
6285 }
6286 {
6287 if (!wxPyCheckForApp()) SWIG_fail;
6288 PyThreadState* __tstate = wxPyBeginAllowThreads();
6289 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6290
6291 wxPyEndAllowThreads(__tstate);
6292 if (PyErr_Occurred()) SWIG_fail;
6293 }
6294 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6295 {
6296 if (arg2) delete [] arg2;
6297 }
6298 return resultobj;
6299 fail:
6300 {
6301 if (arg2) delete [] arg2;
6302 }
6303 return NULL;
6304 }
6305
6306
6307 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6308 PyObject *resultobj;
6309 wxRegion *arg1 = (wxRegion *) 0 ;
6310 PyObject * obj0 = 0 ;
6311 char *kwnames[] = {
6312 (char *) "self", NULL
6313 };
6314
6315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6317 if (SWIG_arg_fail(1)) SWIG_fail;
6318 {
6319 PyThreadState* __tstate = wxPyBeginAllowThreads();
6320 delete arg1;
6321
6322 wxPyEndAllowThreads(__tstate);
6323 if (PyErr_Occurred()) SWIG_fail;
6324 }
6325 Py_INCREF(Py_None); resultobj = Py_None;
6326 return resultobj;
6327 fail:
6328 return NULL;
6329 }
6330
6331
6332 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6333 PyObject *resultobj;
6334 wxRegion *arg1 = (wxRegion *) 0 ;
6335 PyObject * obj0 = 0 ;
6336 char *kwnames[] = {
6337 (char *) "self", NULL
6338 };
6339
6340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6342 if (SWIG_arg_fail(1)) SWIG_fail;
6343 {
6344 PyThreadState* __tstate = wxPyBeginAllowThreads();
6345 (arg1)->Clear();
6346
6347 wxPyEndAllowThreads(__tstate);
6348 if (PyErr_Occurred()) SWIG_fail;
6349 }
6350 Py_INCREF(Py_None); resultobj = Py_None;
6351 return resultobj;
6352 fail:
6353 return NULL;
6354 }
6355
6356
6357 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6358 PyObject *resultobj;
6359 wxRegion *arg1 = (wxRegion *) 0 ;
6360 int arg2 ;
6361 int arg3 ;
6362 bool result;
6363 PyObject * obj0 = 0 ;
6364 PyObject * obj1 = 0 ;
6365 PyObject * obj2 = 0 ;
6366 char *kwnames[] = {
6367 (char *) "self",(char *) "x",(char *) "y", NULL
6368 };
6369
6370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6372 if (SWIG_arg_fail(1)) SWIG_fail;
6373 {
6374 arg2 = (int)(SWIG_As_int(obj1));
6375 if (SWIG_arg_fail(2)) SWIG_fail;
6376 }
6377 {
6378 arg3 = (int)(SWIG_As_int(obj2));
6379 if (SWIG_arg_fail(3)) SWIG_fail;
6380 }
6381 {
6382 PyThreadState* __tstate = wxPyBeginAllowThreads();
6383 result = (bool)(arg1)->Offset(arg2,arg3);
6384
6385 wxPyEndAllowThreads(__tstate);
6386 if (PyErr_Occurred()) SWIG_fail;
6387 }
6388 {
6389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6390 }
6391 return resultobj;
6392 fail:
6393 return NULL;
6394 }
6395
6396
6397 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6398 PyObject *resultobj;
6399 wxRegion *arg1 = (wxRegion *) 0 ;
6400 int arg2 ;
6401 int arg3 ;
6402 wxRegionContain result;
6403 PyObject * obj0 = 0 ;
6404 PyObject * obj1 = 0 ;
6405 PyObject * obj2 = 0 ;
6406 char *kwnames[] = {
6407 (char *) "self",(char *) "x",(char *) "y", NULL
6408 };
6409
6410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6412 if (SWIG_arg_fail(1)) SWIG_fail;
6413 {
6414 arg2 = (int)(SWIG_As_int(obj1));
6415 if (SWIG_arg_fail(2)) SWIG_fail;
6416 }
6417 {
6418 arg3 = (int)(SWIG_As_int(obj2));
6419 if (SWIG_arg_fail(3)) SWIG_fail;
6420 }
6421 {
6422 PyThreadState* __tstate = wxPyBeginAllowThreads();
6423 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6424
6425 wxPyEndAllowThreads(__tstate);
6426 if (PyErr_Occurred()) SWIG_fail;
6427 }
6428 resultobj = SWIG_From_int((result));
6429 return resultobj;
6430 fail:
6431 return NULL;
6432 }
6433
6434
6435 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6436 PyObject *resultobj;
6437 wxRegion *arg1 = (wxRegion *) 0 ;
6438 wxPoint *arg2 = 0 ;
6439 wxRegionContain result;
6440 wxPoint temp2 ;
6441 PyObject * obj0 = 0 ;
6442 PyObject * obj1 = 0 ;
6443 char *kwnames[] = {
6444 (char *) "self",(char *) "pt", NULL
6445 };
6446
6447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6449 if (SWIG_arg_fail(1)) SWIG_fail;
6450 {
6451 arg2 = &temp2;
6452 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6453 }
6454 {
6455 PyThreadState* __tstate = wxPyBeginAllowThreads();
6456 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
6457
6458 wxPyEndAllowThreads(__tstate);
6459 if (PyErr_Occurred()) SWIG_fail;
6460 }
6461 resultobj = SWIG_From_int((result));
6462 return resultobj;
6463 fail:
6464 return NULL;
6465 }
6466
6467
6468 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
6469 PyObject *resultobj;
6470 wxRegion *arg1 = (wxRegion *) 0 ;
6471 wxRect *arg2 = 0 ;
6472 wxRegionContain result;
6473 wxRect temp2 ;
6474 PyObject * obj0 = 0 ;
6475 PyObject * obj1 = 0 ;
6476 char *kwnames[] = {
6477 (char *) "self",(char *) "rect", NULL
6478 };
6479
6480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
6481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6482 if (SWIG_arg_fail(1)) SWIG_fail;
6483 {
6484 arg2 = &temp2;
6485 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6486 }
6487 {
6488 PyThreadState* __tstate = wxPyBeginAllowThreads();
6489 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
6490
6491 wxPyEndAllowThreads(__tstate);
6492 if (PyErr_Occurred()) SWIG_fail;
6493 }
6494 resultobj = SWIG_From_int((result));
6495 return resultobj;
6496 fail:
6497 return NULL;
6498 }
6499
6500
6501 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
6502 PyObject *resultobj;
6503 wxRegion *arg1 = (wxRegion *) 0 ;
6504 int arg2 ;
6505 int arg3 ;
6506 int arg4 ;
6507 int arg5 ;
6508 wxRegionContain result;
6509 PyObject * obj0 = 0 ;
6510 PyObject * obj1 = 0 ;
6511 PyObject * obj2 = 0 ;
6512 PyObject * obj3 = 0 ;
6513 PyObject * obj4 = 0 ;
6514 char *kwnames[] = {
6515 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
6516 };
6517
6518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6520 if (SWIG_arg_fail(1)) SWIG_fail;
6521 {
6522 arg2 = (int)(SWIG_As_int(obj1));
6523 if (SWIG_arg_fail(2)) SWIG_fail;
6524 }
6525 {
6526 arg3 = (int)(SWIG_As_int(obj2));
6527 if (SWIG_arg_fail(3)) SWIG_fail;
6528 }
6529 {
6530 arg4 = (int)(SWIG_As_int(obj3));
6531 if (SWIG_arg_fail(4)) SWIG_fail;
6532 }
6533 {
6534 arg5 = (int)(SWIG_As_int(obj4));
6535 if (SWIG_arg_fail(5)) SWIG_fail;
6536 }
6537 {
6538 PyThreadState* __tstate = wxPyBeginAllowThreads();
6539 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
6540
6541 wxPyEndAllowThreads(__tstate);
6542 if (PyErr_Occurred()) SWIG_fail;
6543 }
6544 resultobj = SWIG_From_int((result));
6545 return resultobj;
6546 fail:
6547 return NULL;
6548 }
6549
6550
6551 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
6552 PyObject *resultobj;
6553 wxRegion *arg1 = (wxRegion *) 0 ;
6554 wxRect result;
6555 PyObject * obj0 = 0 ;
6556 char *kwnames[] = {
6557 (char *) "self", NULL
6558 };
6559
6560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
6561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6562 if (SWIG_arg_fail(1)) SWIG_fail;
6563 {
6564 PyThreadState* __tstate = wxPyBeginAllowThreads();
6565 result = (arg1)->GetBox();
6566
6567 wxPyEndAllowThreads(__tstate);
6568 if (PyErr_Occurred()) SWIG_fail;
6569 }
6570 {
6571 wxRect * resultptr;
6572 resultptr = new wxRect((wxRect &)(result));
6573 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6574 }
6575 return resultobj;
6576 fail:
6577 return NULL;
6578 }
6579
6580
6581 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
6582 PyObject *resultobj;
6583 wxRegion *arg1 = (wxRegion *) 0 ;
6584 int arg2 ;
6585 int arg3 ;
6586 int arg4 ;
6587 int arg5 ;
6588 bool result;
6589 PyObject * obj0 = 0 ;
6590 PyObject * obj1 = 0 ;
6591 PyObject * obj2 = 0 ;
6592 PyObject * obj3 = 0 ;
6593 PyObject * obj4 = 0 ;
6594 char *kwnames[] = {
6595 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6596 };
6597
6598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6600 if (SWIG_arg_fail(1)) SWIG_fail;
6601 {
6602 arg2 = (int)(SWIG_As_int(obj1));
6603 if (SWIG_arg_fail(2)) SWIG_fail;
6604 }
6605 {
6606 arg3 = (int)(SWIG_As_int(obj2));
6607 if (SWIG_arg_fail(3)) SWIG_fail;
6608 }
6609 {
6610 arg4 = (int)(SWIG_As_int(obj3));
6611 if (SWIG_arg_fail(4)) SWIG_fail;
6612 }
6613 {
6614 arg5 = (int)(SWIG_As_int(obj4));
6615 if (SWIG_arg_fail(5)) SWIG_fail;
6616 }
6617 {
6618 PyThreadState* __tstate = wxPyBeginAllowThreads();
6619 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
6620
6621 wxPyEndAllowThreads(__tstate);
6622 if (PyErr_Occurred()) SWIG_fail;
6623 }
6624 {
6625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6626 }
6627 return resultobj;
6628 fail:
6629 return NULL;
6630 }
6631
6632
6633 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6634 PyObject *resultobj;
6635 wxRegion *arg1 = (wxRegion *) 0 ;
6636 wxRect *arg2 = 0 ;
6637 bool result;
6638 wxRect temp2 ;
6639 PyObject * obj0 = 0 ;
6640 PyObject * obj1 = 0 ;
6641 char *kwnames[] = {
6642 (char *) "self",(char *) "rect", NULL
6643 };
6644
6645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6647 if (SWIG_arg_fail(1)) SWIG_fail;
6648 {
6649 arg2 = &temp2;
6650 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6651 }
6652 {
6653 PyThreadState* __tstate = wxPyBeginAllowThreads();
6654 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
6655
6656 wxPyEndAllowThreads(__tstate);
6657 if (PyErr_Occurred()) SWIG_fail;
6658 }
6659 {
6660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6661 }
6662 return resultobj;
6663 fail:
6664 return NULL;
6665 }
6666
6667
6668 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6669 PyObject *resultobj;
6670 wxRegion *arg1 = (wxRegion *) 0 ;
6671 wxRegion *arg2 = 0 ;
6672 bool result;
6673 PyObject * obj0 = 0 ;
6674 PyObject * obj1 = 0 ;
6675 char *kwnames[] = {
6676 (char *) "self",(char *) "region", NULL
6677 };
6678
6679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
6680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6681 if (SWIG_arg_fail(1)) SWIG_fail;
6682 {
6683 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6684 if (SWIG_arg_fail(2)) SWIG_fail;
6685 if (arg2 == NULL) {
6686 SWIG_null_ref("wxRegion");
6687 }
6688 if (SWIG_arg_fail(2)) SWIG_fail;
6689 }
6690 {
6691 PyThreadState* __tstate = wxPyBeginAllowThreads();
6692 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
6693
6694 wxPyEndAllowThreads(__tstate);
6695 if (PyErr_Occurred()) SWIG_fail;
6696 }
6697 {
6698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6699 }
6700 return resultobj;
6701 fail:
6702 return NULL;
6703 }
6704
6705
6706 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
6707 PyObject *resultobj;
6708 wxRegion *arg1 = (wxRegion *) 0 ;
6709 bool result;
6710 PyObject * obj0 = 0 ;
6711 char *kwnames[] = {
6712 (char *) "self", NULL
6713 };
6714
6715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
6716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6717 if (SWIG_arg_fail(1)) SWIG_fail;
6718 {
6719 PyThreadState* __tstate = wxPyBeginAllowThreads();
6720 result = (bool)(arg1)->IsEmpty();
6721
6722 wxPyEndAllowThreads(__tstate);
6723 if (PyErr_Occurred()) SWIG_fail;
6724 }
6725 {
6726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6727 }
6728 return resultobj;
6729 fail:
6730 return NULL;
6731 }
6732
6733
6734 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6735 PyObject *resultobj;
6736 wxRegion *arg1 = (wxRegion *) 0 ;
6737 int arg2 ;
6738 int arg3 ;
6739 int arg4 ;
6740 int arg5 ;
6741 bool result;
6742 PyObject * obj0 = 0 ;
6743 PyObject * obj1 = 0 ;
6744 PyObject * obj2 = 0 ;
6745 PyObject * obj3 = 0 ;
6746 PyObject * obj4 = 0 ;
6747 char *kwnames[] = {
6748 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6749 };
6750
6751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6753 if (SWIG_arg_fail(1)) SWIG_fail;
6754 {
6755 arg2 = (int)(SWIG_As_int(obj1));
6756 if (SWIG_arg_fail(2)) SWIG_fail;
6757 }
6758 {
6759 arg3 = (int)(SWIG_As_int(obj2));
6760 if (SWIG_arg_fail(3)) SWIG_fail;
6761 }
6762 {
6763 arg4 = (int)(SWIG_As_int(obj3));
6764 if (SWIG_arg_fail(4)) SWIG_fail;
6765 }
6766 {
6767 arg5 = (int)(SWIG_As_int(obj4));
6768 if (SWIG_arg_fail(5)) SWIG_fail;
6769 }
6770 {
6771 PyThreadState* __tstate = wxPyBeginAllowThreads();
6772 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
6773
6774 wxPyEndAllowThreads(__tstate);
6775 if (PyErr_Occurred()) SWIG_fail;
6776 }
6777 {
6778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6779 }
6780 return resultobj;
6781 fail:
6782 return NULL;
6783 }
6784
6785
6786 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
6787 PyObject *resultobj;
6788 wxRegion *arg1 = (wxRegion *) 0 ;
6789 wxRect *arg2 = 0 ;
6790 bool result;
6791 wxRect temp2 ;
6792 PyObject * obj0 = 0 ;
6793 PyObject * obj1 = 0 ;
6794 char *kwnames[] = {
6795 (char *) "self",(char *) "rect", NULL
6796 };
6797
6798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
6799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6800 if (SWIG_arg_fail(1)) SWIG_fail;
6801 {
6802 arg2 = &temp2;
6803 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6804 }
6805 {
6806 PyThreadState* __tstate = wxPyBeginAllowThreads();
6807 result = (bool)(arg1)->Union((wxRect const &)*arg2);
6808
6809 wxPyEndAllowThreads(__tstate);
6810 if (PyErr_Occurred()) SWIG_fail;
6811 }
6812 {
6813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6814 }
6815 return resultobj;
6816 fail:
6817 return NULL;
6818 }
6819
6820
6821 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6822 PyObject *resultobj;
6823 wxRegion *arg1 = (wxRegion *) 0 ;
6824 wxRegion *arg2 = 0 ;
6825 bool result;
6826 PyObject * obj0 = 0 ;
6827 PyObject * obj1 = 0 ;
6828 char *kwnames[] = {
6829 (char *) "self",(char *) "region", NULL
6830 };
6831
6832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
6833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6834 if (SWIG_arg_fail(1)) SWIG_fail;
6835 {
6836 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6837 if (SWIG_arg_fail(2)) SWIG_fail;
6838 if (arg2 == NULL) {
6839 SWIG_null_ref("wxRegion");
6840 }
6841 if (SWIG_arg_fail(2)) SWIG_fail;
6842 }
6843 {
6844 PyThreadState* __tstate = wxPyBeginAllowThreads();
6845 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
6846
6847 wxPyEndAllowThreads(__tstate);
6848 if (PyErr_Occurred()) SWIG_fail;
6849 }
6850 {
6851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6852 }
6853 return resultobj;
6854 fail:
6855 return NULL;
6856 }
6857
6858
6859 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
6860 PyObject *resultobj;
6861 wxRegion *arg1 = (wxRegion *) 0 ;
6862 int arg2 ;
6863 int arg3 ;
6864 int arg4 ;
6865 int arg5 ;
6866 bool result;
6867 PyObject * obj0 = 0 ;
6868 PyObject * obj1 = 0 ;
6869 PyObject * obj2 = 0 ;
6870 PyObject * obj3 = 0 ;
6871 PyObject * obj4 = 0 ;
6872 char *kwnames[] = {
6873 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6874 };
6875
6876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6878 if (SWIG_arg_fail(1)) SWIG_fail;
6879 {
6880 arg2 = (int)(SWIG_As_int(obj1));
6881 if (SWIG_arg_fail(2)) SWIG_fail;
6882 }
6883 {
6884 arg3 = (int)(SWIG_As_int(obj2));
6885 if (SWIG_arg_fail(3)) SWIG_fail;
6886 }
6887 {
6888 arg4 = (int)(SWIG_As_int(obj3));
6889 if (SWIG_arg_fail(4)) SWIG_fail;
6890 }
6891 {
6892 arg5 = (int)(SWIG_As_int(obj4));
6893 if (SWIG_arg_fail(5)) SWIG_fail;
6894 }
6895 {
6896 PyThreadState* __tstate = wxPyBeginAllowThreads();
6897 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
6898
6899 wxPyEndAllowThreads(__tstate);
6900 if (PyErr_Occurred()) SWIG_fail;
6901 }
6902 {
6903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6904 }
6905 return resultobj;
6906 fail:
6907 return NULL;
6908 }
6909
6910
6911 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
6912 PyObject *resultobj;
6913 wxRegion *arg1 = (wxRegion *) 0 ;
6914 wxRect *arg2 = 0 ;
6915 bool result;
6916 wxRect temp2 ;
6917 PyObject * obj0 = 0 ;
6918 PyObject * obj1 = 0 ;
6919 char *kwnames[] = {
6920 (char *) "self",(char *) "rect", NULL
6921 };
6922
6923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
6924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6925 if (SWIG_arg_fail(1)) SWIG_fail;
6926 {
6927 arg2 = &temp2;
6928 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6929 }
6930 {
6931 PyThreadState* __tstate = wxPyBeginAllowThreads();
6932 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
6933
6934 wxPyEndAllowThreads(__tstate);
6935 if (PyErr_Occurred()) SWIG_fail;
6936 }
6937 {
6938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6939 }
6940 return resultobj;
6941 fail:
6942 return NULL;
6943 }
6944
6945
6946 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6947 PyObject *resultobj;
6948 wxRegion *arg1 = (wxRegion *) 0 ;
6949 wxRegion *arg2 = 0 ;
6950 bool result;
6951 PyObject * obj0 = 0 ;
6952 PyObject * obj1 = 0 ;
6953 char *kwnames[] = {
6954 (char *) "self",(char *) "region", NULL
6955 };
6956
6957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
6958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6959 if (SWIG_arg_fail(1)) SWIG_fail;
6960 {
6961 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6962 if (SWIG_arg_fail(2)) SWIG_fail;
6963 if (arg2 == NULL) {
6964 SWIG_null_ref("wxRegion");
6965 }
6966 if (SWIG_arg_fail(2)) SWIG_fail;
6967 }
6968 {
6969 PyThreadState* __tstate = wxPyBeginAllowThreads();
6970 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
6971
6972 wxPyEndAllowThreads(__tstate);
6973 if (PyErr_Occurred()) SWIG_fail;
6974 }
6975 {
6976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6977 }
6978 return resultobj;
6979 fail:
6980 return NULL;
6981 }
6982
6983
6984 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
6985 PyObject *resultobj;
6986 wxRegion *arg1 = (wxRegion *) 0 ;
6987 int arg2 ;
6988 int arg3 ;
6989 int arg4 ;
6990 int arg5 ;
6991 bool result;
6992 PyObject * obj0 = 0 ;
6993 PyObject * obj1 = 0 ;
6994 PyObject * obj2 = 0 ;
6995 PyObject * obj3 = 0 ;
6996 PyObject * obj4 = 0 ;
6997 char *kwnames[] = {
6998 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6999 };
7000
7001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7003 if (SWIG_arg_fail(1)) SWIG_fail;
7004 {
7005 arg2 = (int)(SWIG_As_int(obj1));
7006 if (SWIG_arg_fail(2)) SWIG_fail;
7007 }
7008 {
7009 arg3 = (int)(SWIG_As_int(obj2));
7010 if (SWIG_arg_fail(3)) SWIG_fail;
7011 }
7012 {
7013 arg4 = (int)(SWIG_As_int(obj3));
7014 if (SWIG_arg_fail(4)) SWIG_fail;
7015 }
7016 {
7017 arg5 = (int)(SWIG_As_int(obj4));
7018 if (SWIG_arg_fail(5)) SWIG_fail;
7019 }
7020 {
7021 PyThreadState* __tstate = wxPyBeginAllowThreads();
7022 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
7023
7024 wxPyEndAllowThreads(__tstate);
7025 if (PyErr_Occurred()) SWIG_fail;
7026 }
7027 {
7028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7029 }
7030 return resultobj;
7031 fail:
7032 return NULL;
7033 }
7034
7035
7036 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
7037 PyObject *resultobj;
7038 wxRegion *arg1 = (wxRegion *) 0 ;
7039 wxRect *arg2 = 0 ;
7040 bool result;
7041 wxRect temp2 ;
7042 PyObject * obj0 = 0 ;
7043 PyObject * obj1 = 0 ;
7044 char *kwnames[] = {
7045 (char *) "self",(char *) "rect", NULL
7046 };
7047
7048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7050 if (SWIG_arg_fail(1)) SWIG_fail;
7051 {
7052 arg2 = &temp2;
7053 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7054 }
7055 {
7056 PyThreadState* __tstate = wxPyBeginAllowThreads();
7057 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7058
7059 wxPyEndAllowThreads(__tstate);
7060 if (PyErr_Occurred()) SWIG_fail;
7061 }
7062 {
7063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7064 }
7065 return resultobj;
7066 fail:
7067 return NULL;
7068 }
7069
7070
7071 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7072 PyObject *resultobj;
7073 wxRegion *arg1 = (wxRegion *) 0 ;
7074 wxRegion *arg2 = 0 ;
7075 bool result;
7076 PyObject * obj0 = 0 ;
7077 PyObject * obj1 = 0 ;
7078 char *kwnames[] = {
7079 (char *) "self",(char *) "region", NULL
7080 };
7081
7082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7084 if (SWIG_arg_fail(1)) SWIG_fail;
7085 {
7086 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7087 if (SWIG_arg_fail(2)) SWIG_fail;
7088 if (arg2 == NULL) {
7089 SWIG_null_ref("wxRegion");
7090 }
7091 if (SWIG_arg_fail(2)) SWIG_fail;
7092 }
7093 {
7094 PyThreadState* __tstate = wxPyBeginAllowThreads();
7095 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7096
7097 wxPyEndAllowThreads(__tstate);
7098 if (PyErr_Occurred()) SWIG_fail;
7099 }
7100 {
7101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7102 }
7103 return resultobj;
7104 fail:
7105 return NULL;
7106 }
7107
7108
7109 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7110 PyObject *resultobj;
7111 wxRegion *arg1 = (wxRegion *) 0 ;
7112 SwigValueWrapper<wxBitmap > result;
7113 PyObject * obj0 = 0 ;
7114 char *kwnames[] = {
7115 (char *) "self", NULL
7116 };
7117
7118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7120 if (SWIG_arg_fail(1)) SWIG_fail;
7121 {
7122 PyThreadState* __tstate = wxPyBeginAllowThreads();
7123 result = (arg1)->ConvertToBitmap();
7124
7125 wxPyEndAllowThreads(__tstate);
7126 if (PyErr_Occurred()) SWIG_fail;
7127 }
7128 {
7129 wxBitmap * resultptr;
7130 resultptr = new wxBitmap((wxBitmap &)(result));
7131 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7132 }
7133 return resultobj;
7134 fail:
7135 return NULL;
7136 }
7137
7138
7139 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7140 PyObject *resultobj;
7141 wxRegion *arg1 = (wxRegion *) 0 ;
7142 wxBitmap *arg2 = 0 ;
7143 bool result;
7144 PyObject * obj0 = 0 ;
7145 PyObject * obj1 = 0 ;
7146 char *kwnames[] = {
7147 (char *) "self",(char *) "bmp", NULL
7148 };
7149
7150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7152 if (SWIG_arg_fail(1)) SWIG_fail;
7153 {
7154 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7155 if (SWIG_arg_fail(2)) SWIG_fail;
7156 if (arg2 == NULL) {
7157 SWIG_null_ref("wxBitmap");
7158 }
7159 if (SWIG_arg_fail(2)) SWIG_fail;
7160 }
7161 {
7162 PyThreadState* __tstate = wxPyBeginAllowThreads();
7163 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7164
7165 wxPyEndAllowThreads(__tstate);
7166 if (PyErr_Occurred()) SWIG_fail;
7167 }
7168 {
7169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7170 }
7171 return resultobj;
7172 fail:
7173 return NULL;
7174 }
7175
7176
7177 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7178 PyObject *resultobj;
7179 wxRegion *arg1 = (wxRegion *) 0 ;
7180 wxBitmap *arg2 = 0 ;
7181 wxColour *arg3 = 0 ;
7182 int arg4 = (int) 0 ;
7183 bool result;
7184 wxColour temp3 ;
7185 PyObject * obj0 = 0 ;
7186 PyObject * obj1 = 0 ;
7187 PyObject * obj2 = 0 ;
7188 PyObject * obj3 = 0 ;
7189 char *kwnames[] = {
7190 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7191 };
7192
7193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7195 if (SWIG_arg_fail(1)) SWIG_fail;
7196 {
7197 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7198 if (SWIG_arg_fail(2)) SWIG_fail;
7199 if (arg2 == NULL) {
7200 SWIG_null_ref("wxBitmap");
7201 }
7202 if (SWIG_arg_fail(2)) SWIG_fail;
7203 }
7204 {
7205 arg3 = &temp3;
7206 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7207 }
7208 if (obj3) {
7209 {
7210 arg4 = (int)(SWIG_As_int(obj3));
7211 if (SWIG_arg_fail(4)) SWIG_fail;
7212 }
7213 }
7214 {
7215 PyThreadState* __tstate = wxPyBeginAllowThreads();
7216 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7217
7218 wxPyEndAllowThreads(__tstate);
7219 if (PyErr_Occurred()) SWIG_fail;
7220 }
7221 {
7222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7223 }
7224 return resultobj;
7225 fail:
7226 return NULL;
7227 }
7228
7229
7230 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7231 PyObject *obj;
7232 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7233 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7234 Py_INCREF(obj);
7235 return Py_BuildValue((char *)"");
7236 }
7237 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7238 PyObject *resultobj;
7239 wxRegion *arg1 = 0 ;
7240 wxRegionIterator *result;
7241 PyObject * obj0 = 0 ;
7242 char *kwnames[] = {
7243 (char *) "region", NULL
7244 };
7245
7246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7247 {
7248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7249 if (SWIG_arg_fail(1)) SWIG_fail;
7250 if (arg1 == NULL) {
7251 SWIG_null_ref("wxRegion");
7252 }
7253 if (SWIG_arg_fail(1)) SWIG_fail;
7254 }
7255 {
7256 if (!wxPyCheckForApp()) SWIG_fail;
7257 PyThreadState* __tstate = wxPyBeginAllowThreads();
7258 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7259
7260 wxPyEndAllowThreads(__tstate);
7261 if (PyErr_Occurred()) SWIG_fail;
7262 }
7263 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7264 return resultobj;
7265 fail:
7266 return NULL;
7267 }
7268
7269
7270 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7271 PyObject *resultobj;
7272 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7273 PyObject * obj0 = 0 ;
7274 char *kwnames[] = {
7275 (char *) "self", NULL
7276 };
7277
7278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7280 if (SWIG_arg_fail(1)) SWIG_fail;
7281 {
7282 PyThreadState* __tstate = wxPyBeginAllowThreads();
7283 delete arg1;
7284
7285 wxPyEndAllowThreads(__tstate);
7286 if (PyErr_Occurred()) SWIG_fail;
7287 }
7288 Py_INCREF(Py_None); resultobj = Py_None;
7289 return resultobj;
7290 fail:
7291 return NULL;
7292 }
7293
7294
7295 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7296 PyObject *resultobj;
7297 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7298 int result;
7299 PyObject * obj0 = 0 ;
7300 char *kwnames[] = {
7301 (char *) "self", NULL
7302 };
7303
7304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7306 if (SWIG_arg_fail(1)) SWIG_fail;
7307 {
7308 PyThreadState* __tstate = wxPyBeginAllowThreads();
7309 result = (int)(arg1)->GetX();
7310
7311 wxPyEndAllowThreads(__tstate);
7312 if (PyErr_Occurred()) SWIG_fail;
7313 }
7314 {
7315 resultobj = SWIG_From_int((int)(result));
7316 }
7317 return resultobj;
7318 fail:
7319 return NULL;
7320 }
7321
7322
7323 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7324 PyObject *resultobj;
7325 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7326 int result;
7327 PyObject * obj0 = 0 ;
7328 char *kwnames[] = {
7329 (char *) "self", NULL
7330 };
7331
7332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7334 if (SWIG_arg_fail(1)) SWIG_fail;
7335 {
7336 PyThreadState* __tstate = wxPyBeginAllowThreads();
7337 result = (int)(arg1)->GetY();
7338
7339 wxPyEndAllowThreads(__tstate);
7340 if (PyErr_Occurred()) SWIG_fail;
7341 }
7342 {
7343 resultobj = SWIG_From_int((int)(result));
7344 }
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7352 PyObject *resultobj;
7353 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7354 int result;
7355 PyObject * obj0 = 0 ;
7356 char *kwnames[] = {
7357 (char *) "self", NULL
7358 };
7359
7360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7362 if (SWIG_arg_fail(1)) SWIG_fail;
7363 {
7364 PyThreadState* __tstate = wxPyBeginAllowThreads();
7365 result = (int)(arg1)->GetW();
7366
7367 wxPyEndAllowThreads(__tstate);
7368 if (PyErr_Occurred()) SWIG_fail;
7369 }
7370 {
7371 resultobj = SWIG_From_int((int)(result));
7372 }
7373 return resultobj;
7374 fail:
7375 return NULL;
7376 }
7377
7378
7379 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7380 PyObject *resultobj;
7381 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7382 int result;
7383 PyObject * obj0 = 0 ;
7384 char *kwnames[] = {
7385 (char *) "self", NULL
7386 };
7387
7388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7390 if (SWIG_arg_fail(1)) SWIG_fail;
7391 {
7392 PyThreadState* __tstate = wxPyBeginAllowThreads();
7393 result = (int)(arg1)->GetWidth();
7394
7395 wxPyEndAllowThreads(__tstate);
7396 if (PyErr_Occurred()) SWIG_fail;
7397 }
7398 {
7399 resultobj = SWIG_From_int((int)(result));
7400 }
7401 return resultobj;
7402 fail:
7403 return NULL;
7404 }
7405
7406
7407 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7408 PyObject *resultobj;
7409 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7410 int result;
7411 PyObject * obj0 = 0 ;
7412 char *kwnames[] = {
7413 (char *) "self", NULL
7414 };
7415
7416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7418 if (SWIG_arg_fail(1)) SWIG_fail;
7419 {
7420 PyThreadState* __tstate = wxPyBeginAllowThreads();
7421 result = (int)(arg1)->GetH();
7422
7423 wxPyEndAllowThreads(__tstate);
7424 if (PyErr_Occurred()) SWIG_fail;
7425 }
7426 {
7427 resultobj = SWIG_From_int((int)(result));
7428 }
7429 return resultobj;
7430 fail:
7431 return NULL;
7432 }
7433
7434
7435 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7436 PyObject *resultobj;
7437 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7438 int result;
7439 PyObject * obj0 = 0 ;
7440 char *kwnames[] = {
7441 (char *) "self", NULL
7442 };
7443
7444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7446 if (SWIG_arg_fail(1)) SWIG_fail;
7447 {
7448 PyThreadState* __tstate = wxPyBeginAllowThreads();
7449 result = (int)(arg1)->GetHeight();
7450
7451 wxPyEndAllowThreads(__tstate);
7452 if (PyErr_Occurred()) SWIG_fail;
7453 }
7454 {
7455 resultobj = SWIG_From_int((int)(result));
7456 }
7457 return resultobj;
7458 fail:
7459 return NULL;
7460 }
7461
7462
7463 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
7464 PyObject *resultobj;
7465 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7466 wxRect result;
7467 PyObject * obj0 = 0 ;
7468 char *kwnames[] = {
7469 (char *) "self", NULL
7470 };
7471
7472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
7473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7474 if (SWIG_arg_fail(1)) SWIG_fail;
7475 {
7476 PyThreadState* __tstate = wxPyBeginAllowThreads();
7477 result = (arg1)->GetRect();
7478
7479 wxPyEndAllowThreads(__tstate);
7480 if (PyErr_Occurred()) SWIG_fail;
7481 }
7482 {
7483 wxRect * resultptr;
7484 resultptr = new wxRect((wxRect &)(result));
7485 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7486 }
7487 return resultobj;
7488 fail:
7489 return NULL;
7490 }
7491
7492
7493 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
7494 PyObject *resultobj;
7495 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7496 bool result;
7497 PyObject * obj0 = 0 ;
7498 char *kwnames[] = {
7499 (char *) "self", NULL
7500 };
7501
7502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
7503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7504 if (SWIG_arg_fail(1)) SWIG_fail;
7505 {
7506 PyThreadState* __tstate = wxPyBeginAllowThreads();
7507 result = (bool)(arg1)->HaveRects();
7508
7509 wxPyEndAllowThreads(__tstate);
7510 if (PyErr_Occurred()) SWIG_fail;
7511 }
7512 {
7513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7514 }
7515 return resultobj;
7516 fail:
7517 return NULL;
7518 }
7519
7520
7521 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
7522 PyObject *resultobj;
7523 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7524 PyObject * obj0 = 0 ;
7525 char *kwnames[] = {
7526 (char *) "self", NULL
7527 };
7528
7529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
7530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7531 if (SWIG_arg_fail(1)) SWIG_fail;
7532 {
7533 PyThreadState* __tstate = wxPyBeginAllowThreads();
7534 (arg1)->Reset();
7535
7536 wxPyEndAllowThreads(__tstate);
7537 if (PyErr_Occurred()) SWIG_fail;
7538 }
7539 Py_INCREF(Py_None); resultobj = Py_None;
7540 return resultobj;
7541 fail:
7542 return NULL;
7543 }
7544
7545
7546 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
7547 PyObject *resultobj;
7548 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7549 PyObject * obj0 = 0 ;
7550 char *kwnames[] = {
7551 (char *) "self", NULL
7552 };
7553
7554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
7555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7556 if (SWIG_arg_fail(1)) SWIG_fail;
7557 {
7558 PyThreadState* __tstate = wxPyBeginAllowThreads();
7559 wxRegionIterator_Next(arg1);
7560
7561 wxPyEndAllowThreads(__tstate);
7562 if (PyErr_Occurred()) SWIG_fail;
7563 }
7564 Py_INCREF(Py_None); resultobj = Py_None;
7565 return resultobj;
7566 fail:
7567 return NULL;
7568 }
7569
7570
7571 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
7572 PyObject *resultobj;
7573 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7574 bool result;
7575 PyObject * obj0 = 0 ;
7576 char *kwnames[] = {
7577 (char *) "self", NULL
7578 };
7579
7580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
7581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7582 if (SWIG_arg_fail(1)) SWIG_fail;
7583 {
7584 PyThreadState* __tstate = wxPyBeginAllowThreads();
7585 result = (bool)wxRegionIterator___nonzero__(arg1);
7586
7587 wxPyEndAllowThreads(__tstate);
7588 if (PyErr_Occurred()) SWIG_fail;
7589 }
7590 {
7591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7592 }
7593 return resultobj;
7594 fail:
7595 return NULL;
7596 }
7597
7598
7599 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
7600 PyObject *obj;
7601 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7602 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
7603 Py_INCREF(obj);
7604 return Py_BuildValue((char *)"");
7605 }
7606 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7607 PyObject *resultobj;
7608 wxNativeFontInfo *result;
7609 char *kwnames[] = {
7610 NULL
7611 };
7612
7613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
7614 {
7615 PyThreadState* __tstate = wxPyBeginAllowThreads();
7616 result = (wxNativeFontInfo *)new wxNativeFontInfo();
7617
7618 wxPyEndAllowThreads(__tstate);
7619 if (PyErr_Occurred()) SWIG_fail;
7620 }
7621 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
7622 return resultobj;
7623 fail:
7624 return NULL;
7625 }
7626
7627
7628 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7629 PyObject *resultobj;
7630 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7631 PyObject * obj0 = 0 ;
7632 char *kwnames[] = {
7633 (char *) "self", NULL
7634 };
7635
7636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
7637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7638 if (SWIG_arg_fail(1)) SWIG_fail;
7639 {
7640 PyThreadState* __tstate = wxPyBeginAllowThreads();
7641 delete arg1;
7642
7643 wxPyEndAllowThreads(__tstate);
7644 if (PyErr_Occurred()) SWIG_fail;
7645 }
7646 Py_INCREF(Py_None); resultobj = Py_None;
7647 return resultobj;
7648 fail:
7649 return NULL;
7650 }
7651
7652
7653 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
7654 PyObject *resultobj;
7655 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7656 PyObject * obj0 = 0 ;
7657 char *kwnames[] = {
7658 (char *) "self", NULL
7659 };
7660
7661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
7662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7663 if (SWIG_arg_fail(1)) SWIG_fail;
7664 {
7665 PyThreadState* __tstate = wxPyBeginAllowThreads();
7666 (arg1)->Init();
7667
7668 wxPyEndAllowThreads(__tstate);
7669 if (PyErr_Occurred()) SWIG_fail;
7670 }
7671 Py_INCREF(Py_None); resultobj = Py_None;
7672 return resultobj;
7673 fail:
7674 return NULL;
7675 }
7676
7677
7678 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
7679 PyObject *resultobj;
7680 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7681 wxFont *arg2 = 0 ;
7682 PyObject * obj0 = 0 ;
7683 PyObject * obj1 = 0 ;
7684 char *kwnames[] = {
7685 (char *) "self",(char *) "font", NULL
7686 };
7687
7688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
7689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7690 if (SWIG_arg_fail(1)) SWIG_fail;
7691 {
7692 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
7693 if (SWIG_arg_fail(2)) SWIG_fail;
7694 if (arg2 == NULL) {
7695 SWIG_null_ref("wxFont");
7696 }
7697 if (SWIG_arg_fail(2)) SWIG_fail;
7698 }
7699 {
7700 PyThreadState* __tstate = wxPyBeginAllowThreads();
7701 (arg1)->InitFromFont((wxFont const &)*arg2);
7702
7703 wxPyEndAllowThreads(__tstate);
7704 if (PyErr_Occurred()) SWIG_fail;
7705 }
7706 Py_INCREF(Py_None); resultobj = Py_None;
7707 return resultobj;
7708 fail:
7709 return NULL;
7710 }
7711
7712
7713 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7714 PyObject *resultobj;
7715 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7716 int result;
7717 PyObject * obj0 = 0 ;
7718 char *kwnames[] = {
7719 (char *) "self", NULL
7720 };
7721
7722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
7723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7724 if (SWIG_arg_fail(1)) SWIG_fail;
7725 {
7726 PyThreadState* __tstate = wxPyBeginAllowThreads();
7727 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
7728
7729 wxPyEndAllowThreads(__tstate);
7730 if (PyErr_Occurred()) SWIG_fail;
7731 }
7732 {
7733 resultobj = SWIG_From_int((int)(result));
7734 }
7735 return resultobj;
7736 fail:
7737 return NULL;
7738 }
7739
7740
7741 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7742 PyObject *resultobj;
7743 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7744 wxFontStyle result;
7745 PyObject * obj0 = 0 ;
7746 char *kwnames[] = {
7747 (char *) "self", NULL
7748 };
7749
7750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
7751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7752 if (SWIG_arg_fail(1)) SWIG_fail;
7753 {
7754 PyThreadState* __tstate = wxPyBeginAllowThreads();
7755 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
7756
7757 wxPyEndAllowThreads(__tstate);
7758 if (PyErr_Occurred()) SWIG_fail;
7759 }
7760 resultobj = SWIG_From_int((result));
7761 return resultobj;
7762 fail:
7763 return NULL;
7764 }
7765
7766
7767 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7768 PyObject *resultobj;
7769 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7770 wxFontWeight result;
7771 PyObject * obj0 = 0 ;
7772 char *kwnames[] = {
7773 (char *) "self", NULL
7774 };
7775
7776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
7777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7778 if (SWIG_arg_fail(1)) SWIG_fail;
7779 {
7780 PyThreadState* __tstate = wxPyBeginAllowThreads();
7781 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
7782
7783 wxPyEndAllowThreads(__tstate);
7784 if (PyErr_Occurred()) SWIG_fail;
7785 }
7786 resultobj = SWIG_From_int((result));
7787 return resultobj;
7788 fail:
7789 return NULL;
7790 }
7791
7792
7793 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7794 PyObject *resultobj;
7795 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7796 bool result;
7797 PyObject * obj0 = 0 ;
7798 char *kwnames[] = {
7799 (char *) "self", NULL
7800 };
7801
7802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
7803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7804 if (SWIG_arg_fail(1)) SWIG_fail;
7805 {
7806 PyThreadState* __tstate = wxPyBeginAllowThreads();
7807 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
7808
7809 wxPyEndAllowThreads(__tstate);
7810 if (PyErr_Occurred()) SWIG_fail;
7811 }
7812 {
7813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7814 }
7815 return resultobj;
7816 fail:
7817 return NULL;
7818 }
7819
7820
7821 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7822 PyObject *resultobj;
7823 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7824 wxString result;
7825 PyObject * obj0 = 0 ;
7826 char *kwnames[] = {
7827 (char *) "self", NULL
7828 };
7829
7830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
7831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7832 if (SWIG_arg_fail(1)) SWIG_fail;
7833 {
7834 PyThreadState* __tstate = wxPyBeginAllowThreads();
7835 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
7836
7837 wxPyEndAllowThreads(__tstate);
7838 if (PyErr_Occurred()) SWIG_fail;
7839 }
7840 {
7841 #if wxUSE_UNICODE
7842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7843 #else
7844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7845 #endif
7846 }
7847 return resultobj;
7848 fail:
7849 return NULL;
7850 }
7851
7852
7853 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
7854 PyObject *resultobj;
7855 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7856 wxFontFamily result;
7857 PyObject * obj0 = 0 ;
7858 char *kwnames[] = {
7859 (char *) "self", NULL
7860 };
7861
7862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
7863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7864 if (SWIG_arg_fail(1)) SWIG_fail;
7865 {
7866 PyThreadState* __tstate = wxPyBeginAllowThreads();
7867 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
7868
7869 wxPyEndAllowThreads(__tstate);
7870 if (PyErr_Occurred()) SWIG_fail;
7871 }
7872 resultobj = SWIG_From_int((result));
7873 return resultobj;
7874 fail:
7875 return NULL;
7876 }
7877
7878
7879 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
7880 PyObject *resultobj;
7881 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7882 wxFontEncoding result;
7883 PyObject * obj0 = 0 ;
7884 char *kwnames[] = {
7885 (char *) "self", NULL
7886 };
7887
7888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
7889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7890 if (SWIG_arg_fail(1)) SWIG_fail;
7891 {
7892 PyThreadState* __tstate = wxPyBeginAllowThreads();
7893 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
7894
7895 wxPyEndAllowThreads(__tstate);
7896 if (PyErr_Occurred()) SWIG_fail;
7897 }
7898 resultobj = SWIG_From_int((result));
7899 return resultobj;
7900 fail:
7901 return NULL;
7902 }
7903
7904
7905 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7906 PyObject *resultobj;
7907 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7908 int arg2 ;
7909 PyObject * obj0 = 0 ;
7910 PyObject * obj1 = 0 ;
7911 char *kwnames[] = {
7912 (char *) "self",(char *) "pointsize", NULL
7913 };
7914
7915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
7916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7917 if (SWIG_arg_fail(1)) SWIG_fail;
7918 {
7919 arg2 = (int)(SWIG_As_int(obj1));
7920 if (SWIG_arg_fail(2)) SWIG_fail;
7921 }
7922 {
7923 PyThreadState* __tstate = wxPyBeginAllowThreads();
7924 (arg1)->SetPointSize(arg2);
7925
7926 wxPyEndAllowThreads(__tstate);
7927 if (PyErr_Occurred()) SWIG_fail;
7928 }
7929 Py_INCREF(Py_None); resultobj = Py_None;
7930 return resultobj;
7931 fail:
7932 return NULL;
7933 }
7934
7935
7936 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7937 PyObject *resultobj;
7938 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7939 wxFontStyle arg2 ;
7940 PyObject * obj0 = 0 ;
7941 PyObject * obj1 = 0 ;
7942 char *kwnames[] = {
7943 (char *) "self",(char *) "style", NULL
7944 };
7945
7946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
7947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7948 if (SWIG_arg_fail(1)) SWIG_fail;
7949 {
7950 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
7951 if (SWIG_arg_fail(2)) SWIG_fail;
7952 }
7953 {
7954 PyThreadState* __tstate = wxPyBeginAllowThreads();
7955 (arg1)->SetStyle((wxFontStyle )arg2);
7956
7957 wxPyEndAllowThreads(__tstate);
7958 if (PyErr_Occurred()) SWIG_fail;
7959 }
7960 Py_INCREF(Py_None); resultobj = Py_None;
7961 return resultobj;
7962 fail:
7963 return NULL;
7964 }
7965
7966
7967 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7968 PyObject *resultobj;
7969 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7970 wxFontWeight arg2 ;
7971 PyObject * obj0 = 0 ;
7972 PyObject * obj1 = 0 ;
7973 char *kwnames[] = {
7974 (char *) "self",(char *) "weight", NULL
7975 };
7976
7977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
7978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7979 if (SWIG_arg_fail(1)) SWIG_fail;
7980 {
7981 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
7982 if (SWIG_arg_fail(2)) SWIG_fail;
7983 }
7984 {
7985 PyThreadState* __tstate = wxPyBeginAllowThreads();
7986 (arg1)->SetWeight((wxFontWeight )arg2);
7987
7988 wxPyEndAllowThreads(__tstate);
7989 if (PyErr_Occurred()) SWIG_fail;
7990 }
7991 Py_INCREF(Py_None); resultobj = Py_None;
7992 return resultobj;
7993 fail:
7994 return NULL;
7995 }
7996
7997
7998 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7999 PyObject *resultobj;
8000 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8001 bool arg2 ;
8002 PyObject * obj0 = 0 ;
8003 PyObject * obj1 = 0 ;
8004 char *kwnames[] = {
8005 (char *) "self",(char *) "underlined", NULL
8006 };
8007
8008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
8009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8010 if (SWIG_arg_fail(1)) SWIG_fail;
8011 {
8012 arg2 = (bool)(SWIG_As_bool(obj1));
8013 if (SWIG_arg_fail(2)) SWIG_fail;
8014 }
8015 {
8016 PyThreadState* __tstate = wxPyBeginAllowThreads();
8017 (arg1)->SetUnderlined(arg2);
8018
8019 wxPyEndAllowThreads(__tstate);
8020 if (PyErr_Occurred()) SWIG_fail;
8021 }
8022 Py_INCREF(Py_None); resultobj = Py_None;
8023 return resultobj;
8024 fail:
8025 return NULL;
8026 }
8027
8028
8029 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8030 PyObject *resultobj;
8031 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8032 wxString arg2 ;
8033 PyObject * obj0 = 0 ;
8034 PyObject * obj1 = 0 ;
8035 char *kwnames[] = {
8036 (char *) "self",(char *) "facename", NULL
8037 };
8038
8039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
8040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8041 if (SWIG_arg_fail(1)) SWIG_fail;
8042 {
8043 wxString* sptr = wxString_in_helper(obj1);
8044 if (sptr == NULL) SWIG_fail;
8045 arg2 = *sptr;
8046 delete sptr;
8047 }
8048 {
8049 PyThreadState* __tstate = wxPyBeginAllowThreads();
8050 (arg1)->SetFaceName(arg2);
8051
8052 wxPyEndAllowThreads(__tstate);
8053 if (PyErr_Occurred()) SWIG_fail;
8054 }
8055 Py_INCREF(Py_None); resultobj = Py_None;
8056 return resultobj;
8057 fail:
8058 return NULL;
8059 }
8060
8061
8062 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8063 PyObject *resultobj;
8064 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8065 wxFontFamily arg2 ;
8066 PyObject * obj0 = 0 ;
8067 PyObject * obj1 = 0 ;
8068 char *kwnames[] = {
8069 (char *) "self",(char *) "family", NULL
8070 };
8071
8072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8074 if (SWIG_arg_fail(1)) SWIG_fail;
8075 {
8076 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8077 if (SWIG_arg_fail(2)) SWIG_fail;
8078 }
8079 {
8080 PyThreadState* __tstate = wxPyBeginAllowThreads();
8081 (arg1)->SetFamily((wxFontFamily )arg2);
8082
8083 wxPyEndAllowThreads(__tstate);
8084 if (PyErr_Occurred()) SWIG_fail;
8085 }
8086 Py_INCREF(Py_None); resultobj = Py_None;
8087 return resultobj;
8088 fail:
8089 return NULL;
8090 }
8091
8092
8093 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8094 PyObject *resultobj;
8095 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8096 wxFontEncoding arg2 ;
8097 PyObject * obj0 = 0 ;
8098 PyObject * obj1 = 0 ;
8099 char *kwnames[] = {
8100 (char *) "self",(char *) "encoding", NULL
8101 };
8102
8103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8105 if (SWIG_arg_fail(1)) SWIG_fail;
8106 {
8107 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8108 if (SWIG_arg_fail(2)) SWIG_fail;
8109 }
8110 {
8111 PyThreadState* __tstate = wxPyBeginAllowThreads();
8112 (arg1)->SetEncoding((wxFontEncoding )arg2);
8113
8114 wxPyEndAllowThreads(__tstate);
8115 if (PyErr_Occurred()) SWIG_fail;
8116 }
8117 Py_INCREF(Py_None); resultobj = Py_None;
8118 return resultobj;
8119 fail:
8120 return NULL;
8121 }
8122
8123
8124 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8125 PyObject *resultobj;
8126 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8127 wxString *arg2 = 0 ;
8128 bool result;
8129 bool temp2 = false ;
8130 PyObject * obj0 = 0 ;
8131 PyObject * obj1 = 0 ;
8132 char *kwnames[] = {
8133 (char *) "self",(char *) "s", NULL
8134 };
8135
8136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8138 if (SWIG_arg_fail(1)) SWIG_fail;
8139 {
8140 arg2 = wxString_in_helper(obj1);
8141 if (arg2 == NULL) SWIG_fail;
8142 temp2 = true;
8143 }
8144 {
8145 PyThreadState* __tstate = wxPyBeginAllowThreads();
8146 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8147
8148 wxPyEndAllowThreads(__tstate);
8149 if (PyErr_Occurred()) SWIG_fail;
8150 }
8151 {
8152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8153 }
8154 {
8155 if (temp2)
8156 delete arg2;
8157 }
8158 return resultobj;
8159 fail:
8160 {
8161 if (temp2)
8162 delete arg2;
8163 }
8164 return NULL;
8165 }
8166
8167
8168 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8169 PyObject *resultobj;
8170 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8171 wxString result;
8172 PyObject * obj0 = 0 ;
8173 char *kwnames[] = {
8174 (char *) "self", NULL
8175 };
8176
8177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8179 if (SWIG_arg_fail(1)) SWIG_fail;
8180 {
8181 PyThreadState* __tstate = wxPyBeginAllowThreads();
8182 result = ((wxNativeFontInfo const *)arg1)->ToString();
8183
8184 wxPyEndAllowThreads(__tstate);
8185 if (PyErr_Occurred()) SWIG_fail;
8186 }
8187 {
8188 #if wxUSE_UNICODE
8189 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8190 #else
8191 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8192 #endif
8193 }
8194 return resultobj;
8195 fail:
8196 return NULL;
8197 }
8198
8199
8200 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8201 PyObject *resultobj;
8202 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8203 wxString result;
8204 PyObject * obj0 = 0 ;
8205 char *kwnames[] = {
8206 (char *) "self", NULL
8207 };
8208
8209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8211 if (SWIG_arg_fail(1)) SWIG_fail;
8212 {
8213 PyThreadState* __tstate = wxPyBeginAllowThreads();
8214 result = wxNativeFontInfo___str__(arg1);
8215
8216 wxPyEndAllowThreads(__tstate);
8217 if (PyErr_Occurred()) SWIG_fail;
8218 }
8219 {
8220 #if wxUSE_UNICODE
8221 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8222 #else
8223 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8224 #endif
8225 }
8226 return resultobj;
8227 fail:
8228 return NULL;
8229 }
8230
8231
8232 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8233 PyObject *resultobj;
8234 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8235 wxString *arg2 = 0 ;
8236 bool result;
8237 bool temp2 = false ;
8238 PyObject * obj0 = 0 ;
8239 PyObject * obj1 = 0 ;
8240 char *kwnames[] = {
8241 (char *) "self",(char *) "s", NULL
8242 };
8243
8244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8246 if (SWIG_arg_fail(1)) SWIG_fail;
8247 {
8248 arg2 = wxString_in_helper(obj1);
8249 if (arg2 == NULL) SWIG_fail;
8250 temp2 = true;
8251 }
8252 {
8253 PyThreadState* __tstate = wxPyBeginAllowThreads();
8254 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8255
8256 wxPyEndAllowThreads(__tstate);
8257 if (PyErr_Occurred()) SWIG_fail;
8258 }
8259 {
8260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8261 }
8262 {
8263 if (temp2)
8264 delete arg2;
8265 }
8266 return resultobj;
8267 fail:
8268 {
8269 if (temp2)
8270 delete arg2;
8271 }
8272 return NULL;
8273 }
8274
8275
8276 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8277 PyObject *resultobj;
8278 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8279 wxString result;
8280 PyObject * obj0 = 0 ;
8281 char *kwnames[] = {
8282 (char *) "self", NULL
8283 };
8284
8285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8287 if (SWIG_arg_fail(1)) SWIG_fail;
8288 {
8289 PyThreadState* __tstate = wxPyBeginAllowThreads();
8290 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8291
8292 wxPyEndAllowThreads(__tstate);
8293 if (PyErr_Occurred()) SWIG_fail;
8294 }
8295 {
8296 #if wxUSE_UNICODE
8297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8298 #else
8299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8300 #endif
8301 }
8302 return resultobj;
8303 fail:
8304 return NULL;
8305 }
8306
8307
8308 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8309 PyObject *obj;
8310 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8311 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8312 Py_INCREF(obj);
8313 return Py_BuildValue((char *)"");
8314 }
8315 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8316 PyObject *resultobj;
8317 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8318 wxString *arg2 = (wxString *) 0 ;
8319 bool temp2 = false ;
8320 PyObject * obj0 = 0 ;
8321 PyObject * obj1 = 0 ;
8322 char *kwnames[] = {
8323 (char *) "self",(char *) "facename", NULL
8324 };
8325
8326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8328 if (SWIG_arg_fail(1)) SWIG_fail;
8329 {
8330 arg2 = wxString_in_helper(obj1);
8331 if (arg2 == NULL) SWIG_fail;
8332 temp2 = true;
8333 }
8334 if (arg1) (arg1)->facename = *arg2;
8335
8336 Py_INCREF(Py_None); resultobj = Py_None;
8337 {
8338 if (temp2)
8339 delete arg2;
8340 }
8341 return resultobj;
8342 fail:
8343 {
8344 if (temp2)
8345 delete arg2;
8346 }
8347 return NULL;
8348 }
8349
8350
8351 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8352 PyObject *resultobj;
8353 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8354 wxString *result;
8355 PyObject * obj0 = 0 ;
8356 char *kwnames[] = {
8357 (char *) "self", NULL
8358 };
8359
8360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
8361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8362 if (SWIG_arg_fail(1)) SWIG_fail;
8363 result = (wxString *)& ((arg1)->facename);
8364
8365 {
8366 #if wxUSE_UNICODE
8367 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8368 #else
8369 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8370 #endif
8371 }
8372 return resultobj;
8373 fail:
8374 return NULL;
8375 }
8376
8377
8378 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8379 PyObject *resultobj;
8380 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8381 wxFontEncoding arg2 ;
8382 PyObject * obj0 = 0 ;
8383 PyObject * obj1 = 0 ;
8384 char *kwnames[] = {
8385 (char *) "self",(char *) "encoding", NULL
8386 };
8387
8388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
8389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8390 if (SWIG_arg_fail(1)) SWIG_fail;
8391 {
8392 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8393 if (SWIG_arg_fail(2)) SWIG_fail;
8394 }
8395 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
8396
8397 Py_INCREF(Py_None); resultobj = Py_None;
8398 return resultobj;
8399 fail:
8400 return NULL;
8401 }
8402
8403
8404 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
8405 PyObject *resultobj;
8406 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8407 wxFontEncoding result;
8408 PyObject * obj0 = 0 ;
8409 char *kwnames[] = {
8410 (char *) "self", NULL
8411 };
8412
8413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
8414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8415 if (SWIG_arg_fail(1)) SWIG_fail;
8416 result = (wxFontEncoding) ((arg1)->encoding);
8417
8418 resultobj = SWIG_From_int((result));
8419 return resultobj;
8420 fail:
8421 return NULL;
8422 }
8423
8424
8425 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8426 PyObject *resultobj;
8427 wxNativeEncodingInfo *result;
8428 char *kwnames[] = {
8429 NULL
8430 };
8431
8432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
8433 {
8434 PyThreadState* __tstate = wxPyBeginAllowThreads();
8435 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
8436
8437 wxPyEndAllowThreads(__tstate);
8438 if (PyErr_Occurred()) SWIG_fail;
8439 }
8440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
8441 return resultobj;
8442 fail:
8443 return NULL;
8444 }
8445
8446
8447 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8448 PyObject *resultobj;
8449 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8450 PyObject * obj0 = 0 ;
8451 char *kwnames[] = {
8452 (char *) "self", NULL
8453 };
8454
8455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
8456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8457 if (SWIG_arg_fail(1)) SWIG_fail;
8458 {
8459 PyThreadState* __tstate = wxPyBeginAllowThreads();
8460 delete arg1;
8461
8462 wxPyEndAllowThreads(__tstate);
8463 if (PyErr_Occurred()) SWIG_fail;
8464 }
8465 Py_INCREF(Py_None); resultobj = Py_None;
8466 return resultobj;
8467 fail:
8468 return NULL;
8469 }
8470
8471
8472 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8473 PyObject *resultobj;
8474 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8475 wxString *arg2 = 0 ;
8476 bool result;
8477 bool temp2 = false ;
8478 PyObject * obj0 = 0 ;
8479 PyObject * obj1 = 0 ;
8480 char *kwnames[] = {
8481 (char *) "self",(char *) "s", NULL
8482 };
8483
8484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8486 if (SWIG_arg_fail(1)) SWIG_fail;
8487 {
8488 arg2 = wxString_in_helper(obj1);
8489 if (arg2 == NULL) SWIG_fail;
8490 temp2 = true;
8491 }
8492 {
8493 PyThreadState* __tstate = wxPyBeginAllowThreads();
8494 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8495
8496 wxPyEndAllowThreads(__tstate);
8497 if (PyErr_Occurred()) SWIG_fail;
8498 }
8499 {
8500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8501 }
8502 {
8503 if (temp2)
8504 delete arg2;
8505 }
8506 return resultobj;
8507 fail:
8508 {
8509 if (temp2)
8510 delete arg2;
8511 }
8512 return NULL;
8513 }
8514
8515
8516 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8517 PyObject *resultobj;
8518 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8519 wxString result;
8520 PyObject * obj0 = 0 ;
8521 char *kwnames[] = {
8522 (char *) "self", NULL
8523 };
8524
8525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
8526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8527 if (SWIG_arg_fail(1)) SWIG_fail;
8528 {
8529 PyThreadState* __tstate = wxPyBeginAllowThreads();
8530 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
8531
8532 wxPyEndAllowThreads(__tstate);
8533 if (PyErr_Occurred()) SWIG_fail;
8534 }
8535 {
8536 #if wxUSE_UNICODE
8537 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8538 #else
8539 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8540 #endif
8541 }
8542 return resultobj;
8543 fail:
8544 return NULL;
8545 }
8546
8547
8548 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
8549 PyObject *obj;
8550 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8551 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
8552 Py_INCREF(obj);
8553 return Py_BuildValue((char *)"");
8554 }
8555 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8556 PyObject *resultobj;
8557 wxFontEncoding arg1 ;
8558 wxNativeEncodingInfo *result;
8559 PyObject * obj0 = 0 ;
8560 char *kwnames[] = {
8561 (char *) "encoding", NULL
8562 };
8563
8564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
8565 {
8566 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8567 if (SWIG_arg_fail(1)) SWIG_fail;
8568 }
8569 {
8570 PyThreadState* __tstate = wxPyBeginAllowThreads();
8571 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
8572
8573 wxPyEndAllowThreads(__tstate);
8574 if (PyErr_Occurred()) SWIG_fail;
8575 }
8576 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
8577 return resultobj;
8578 fail:
8579 return NULL;
8580 }
8581
8582
8583 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8584 PyObject *resultobj;
8585 wxNativeEncodingInfo *arg1 = 0 ;
8586 bool result;
8587 PyObject * obj0 = 0 ;
8588 char *kwnames[] = {
8589 (char *) "info", NULL
8590 };
8591
8592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
8593 {
8594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8595 if (SWIG_arg_fail(1)) SWIG_fail;
8596 if (arg1 == NULL) {
8597 SWIG_null_ref("wxNativeEncodingInfo");
8598 }
8599 if (SWIG_arg_fail(1)) SWIG_fail;
8600 }
8601 {
8602 PyThreadState* __tstate = wxPyBeginAllowThreads();
8603 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
8604
8605 wxPyEndAllowThreads(__tstate);
8606 if (PyErr_Occurred()) SWIG_fail;
8607 }
8608 {
8609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8610 }
8611 return resultobj;
8612 fail:
8613 return NULL;
8614 }
8615
8616
8617 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8618 PyObject *resultobj;
8619 wxFontMapper *result;
8620 char *kwnames[] = {
8621 NULL
8622 };
8623
8624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
8625 {
8626 PyThreadState* __tstate = wxPyBeginAllowThreads();
8627 result = (wxFontMapper *)new wxFontMapper();
8628
8629 wxPyEndAllowThreads(__tstate);
8630 if (PyErr_Occurred()) SWIG_fail;
8631 }
8632 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
8633 return resultobj;
8634 fail:
8635 return NULL;
8636 }
8637
8638
8639 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8640 PyObject *resultobj;
8641 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8642 PyObject * obj0 = 0 ;
8643 char *kwnames[] = {
8644 (char *) "self", NULL
8645 };
8646
8647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
8648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8649 if (SWIG_arg_fail(1)) SWIG_fail;
8650 {
8651 PyThreadState* __tstate = wxPyBeginAllowThreads();
8652 delete arg1;
8653
8654 wxPyEndAllowThreads(__tstate);
8655 if (PyErr_Occurred()) SWIG_fail;
8656 }
8657 Py_INCREF(Py_None); resultobj = Py_None;
8658 return resultobj;
8659 fail:
8660 return NULL;
8661 }
8662
8663
8664 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
8665 PyObject *resultobj;
8666 wxFontMapper *result;
8667 char *kwnames[] = {
8668 NULL
8669 };
8670
8671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
8672 {
8673 PyThreadState* __tstate = wxPyBeginAllowThreads();
8674 result = (wxFontMapper *)wxFontMapper::Get();
8675
8676 wxPyEndAllowThreads(__tstate);
8677 if (PyErr_Occurred()) SWIG_fail;
8678 }
8679 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8680 return resultobj;
8681 fail:
8682 return NULL;
8683 }
8684
8685
8686 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
8687 PyObject *resultobj;
8688 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8689 wxFontMapper *result;
8690 PyObject * obj0 = 0 ;
8691 char *kwnames[] = {
8692 (char *) "mapper", NULL
8693 };
8694
8695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
8696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8697 if (SWIG_arg_fail(1)) SWIG_fail;
8698 {
8699 PyThreadState* __tstate = wxPyBeginAllowThreads();
8700 result = (wxFontMapper *)wxFontMapper::Set(arg1);
8701
8702 wxPyEndAllowThreads(__tstate);
8703 if (PyErr_Occurred()) SWIG_fail;
8704 }
8705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8706 return resultobj;
8707 fail:
8708 return NULL;
8709 }
8710
8711
8712 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8713 PyObject *resultobj;
8714 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8715 wxString *arg2 = 0 ;
8716 bool arg3 = (bool) true ;
8717 wxFontEncoding result;
8718 bool temp2 = false ;
8719 PyObject * obj0 = 0 ;
8720 PyObject * obj1 = 0 ;
8721 PyObject * obj2 = 0 ;
8722 char *kwnames[] = {
8723 (char *) "self",(char *) "charset",(char *) "interactive", NULL
8724 };
8725
8726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
8727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8728 if (SWIG_arg_fail(1)) SWIG_fail;
8729 {
8730 arg2 = wxString_in_helper(obj1);
8731 if (arg2 == NULL) SWIG_fail;
8732 temp2 = true;
8733 }
8734 if (obj2) {
8735 {
8736 arg3 = (bool)(SWIG_As_bool(obj2));
8737 if (SWIG_arg_fail(3)) SWIG_fail;
8738 }
8739 }
8740 {
8741 PyThreadState* __tstate = wxPyBeginAllowThreads();
8742 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
8743
8744 wxPyEndAllowThreads(__tstate);
8745 if (PyErr_Occurred()) SWIG_fail;
8746 }
8747 resultobj = SWIG_From_int((result));
8748 {
8749 if (temp2)
8750 delete arg2;
8751 }
8752 return resultobj;
8753 fail:
8754 {
8755 if (temp2)
8756 delete arg2;
8757 }
8758 return NULL;
8759 }
8760
8761
8762 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
8763 PyObject *resultobj;
8764 size_t result;
8765 char *kwnames[] = {
8766 NULL
8767 };
8768
8769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
8770 {
8771 PyThreadState* __tstate = wxPyBeginAllowThreads();
8772 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
8773
8774 wxPyEndAllowThreads(__tstate);
8775 if (PyErr_Occurred()) SWIG_fail;
8776 }
8777 {
8778 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8779 }
8780 return resultobj;
8781 fail:
8782 return NULL;
8783 }
8784
8785
8786 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8787 PyObject *resultobj;
8788 size_t arg1 ;
8789 wxFontEncoding result;
8790 PyObject * obj0 = 0 ;
8791 char *kwnames[] = {
8792 (char *) "n", NULL
8793 };
8794
8795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
8796 {
8797 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8798 if (SWIG_arg_fail(1)) SWIG_fail;
8799 }
8800 {
8801 PyThreadState* __tstate = wxPyBeginAllowThreads();
8802 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
8803
8804 wxPyEndAllowThreads(__tstate);
8805 if (PyErr_Occurred()) SWIG_fail;
8806 }
8807 resultobj = SWIG_From_int((result));
8808 return resultobj;
8809 fail:
8810 return NULL;
8811 }
8812
8813
8814 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
8815 PyObject *resultobj;
8816 wxFontEncoding arg1 ;
8817 wxString result;
8818 PyObject * obj0 = 0 ;
8819 char *kwnames[] = {
8820 (char *) "encoding", NULL
8821 };
8822
8823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
8824 {
8825 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8826 if (SWIG_arg_fail(1)) SWIG_fail;
8827 }
8828 {
8829 PyThreadState* __tstate = wxPyBeginAllowThreads();
8830 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
8831
8832 wxPyEndAllowThreads(__tstate);
8833 if (PyErr_Occurred()) SWIG_fail;
8834 }
8835 {
8836 #if wxUSE_UNICODE
8837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8838 #else
8839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8840 #endif
8841 }
8842 return resultobj;
8843 fail:
8844 return NULL;
8845 }
8846
8847
8848 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
8849 PyObject *resultobj;
8850 wxFontEncoding arg1 ;
8851 wxString result;
8852 PyObject * obj0 = 0 ;
8853 char *kwnames[] = {
8854 (char *) "encoding", NULL
8855 };
8856
8857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
8858 {
8859 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8860 if (SWIG_arg_fail(1)) SWIG_fail;
8861 }
8862 {
8863 PyThreadState* __tstate = wxPyBeginAllowThreads();
8864 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
8865
8866 wxPyEndAllowThreads(__tstate);
8867 if (PyErr_Occurred()) SWIG_fail;
8868 }
8869 {
8870 #if wxUSE_UNICODE
8871 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8872 #else
8873 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8874 #endif
8875 }
8876 return resultobj;
8877 fail:
8878 return NULL;
8879 }
8880
8881
8882 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
8883 PyObject *resultobj;
8884 wxString *arg1 = 0 ;
8885 wxFontEncoding result;
8886 bool temp1 = false ;
8887 PyObject * obj0 = 0 ;
8888 char *kwnames[] = {
8889 (char *) "name", NULL
8890 };
8891
8892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
8893 {
8894 arg1 = wxString_in_helper(obj0);
8895 if (arg1 == NULL) SWIG_fail;
8896 temp1 = true;
8897 }
8898 {
8899 PyThreadState* __tstate = wxPyBeginAllowThreads();
8900 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
8901
8902 wxPyEndAllowThreads(__tstate);
8903 if (PyErr_Occurred()) SWIG_fail;
8904 }
8905 resultobj = SWIG_From_int((result));
8906 {
8907 if (temp1)
8908 delete arg1;
8909 }
8910 return resultobj;
8911 fail:
8912 {
8913 if (temp1)
8914 delete arg1;
8915 }
8916 return NULL;
8917 }
8918
8919
8920 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
8921 PyObject *resultobj;
8922 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8923 wxConfigBase *arg2 = (wxConfigBase *) 0 ;
8924 PyObject * obj0 = 0 ;
8925 PyObject * obj1 = 0 ;
8926 char *kwnames[] = {
8927 (char *) "self",(char *) "config", NULL
8928 };
8929
8930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
8931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8932 if (SWIG_arg_fail(1)) SWIG_fail;
8933 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8934 if (SWIG_arg_fail(2)) SWIG_fail;
8935 {
8936 PyThreadState* __tstate = wxPyBeginAllowThreads();
8937 (arg1)->SetConfig(arg2);
8938
8939 wxPyEndAllowThreads(__tstate);
8940 if (PyErr_Occurred()) SWIG_fail;
8941 }
8942 Py_INCREF(Py_None); resultobj = Py_None;
8943 return resultobj;
8944 fail:
8945 return NULL;
8946 }
8947
8948
8949 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8950 PyObject *resultobj;
8951 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8952 wxString *arg2 = 0 ;
8953 bool temp2 = false ;
8954 PyObject * obj0 = 0 ;
8955 PyObject * obj1 = 0 ;
8956 char *kwnames[] = {
8957 (char *) "self",(char *) "prefix", NULL
8958 };
8959
8960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
8961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8962 if (SWIG_arg_fail(1)) SWIG_fail;
8963 {
8964 arg2 = wxString_in_helper(obj1);
8965 if (arg2 == NULL) SWIG_fail;
8966 temp2 = true;
8967 }
8968 {
8969 PyThreadState* __tstate = wxPyBeginAllowThreads();
8970 (arg1)->SetConfigPath((wxString const &)*arg2);
8971
8972 wxPyEndAllowThreads(__tstate);
8973 if (PyErr_Occurred()) SWIG_fail;
8974 }
8975 Py_INCREF(Py_None); resultobj = Py_None;
8976 {
8977 if (temp2)
8978 delete arg2;
8979 }
8980 return resultobj;
8981 fail:
8982 {
8983 if (temp2)
8984 delete arg2;
8985 }
8986 return NULL;
8987 }
8988
8989
8990 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8991 PyObject *resultobj;
8992 wxString result;
8993 char *kwnames[] = {
8994 NULL
8995 };
8996
8997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
8998 {
8999 PyThreadState* __tstate = wxPyBeginAllowThreads();
9000 result = wxFontMapper::GetDefaultConfigPath();
9001
9002 wxPyEndAllowThreads(__tstate);
9003 if (PyErr_Occurred()) SWIG_fail;
9004 }
9005 {
9006 #if wxUSE_UNICODE
9007 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9008 #else
9009 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9010 #endif
9011 }
9012 return resultobj;
9013 fail:
9014 return NULL;
9015 }
9016
9017
9018 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9019 PyObject *resultobj;
9020 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9021 wxFontEncoding arg2 ;
9022 wxString const &arg3_defvalue = wxPyEmptyString ;
9023 wxString *arg3 = (wxString *) &arg3_defvalue ;
9024 bool arg4 = (bool) true ;
9025 PyObject *result;
9026 bool temp3 = false ;
9027 PyObject * obj0 = 0 ;
9028 PyObject * obj1 = 0 ;
9029 PyObject * obj2 = 0 ;
9030 PyObject * obj3 = 0 ;
9031 char *kwnames[] = {
9032 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
9033 };
9034
9035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9037 if (SWIG_arg_fail(1)) SWIG_fail;
9038 {
9039 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9040 if (SWIG_arg_fail(2)) SWIG_fail;
9041 }
9042 if (obj2) {
9043 {
9044 arg3 = wxString_in_helper(obj2);
9045 if (arg3 == NULL) SWIG_fail;
9046 temp3 = true;
9047 }
9048 }
9049 if (obj3) {
9050 {
9051 arg4 = (bool)(SWIG_As_bool(obj3));
9052 if (SWIG_arg_fail(4)) SWIG_fail;
9053 }
9054 }
9055 {
9056 PyThreadState* __tstate = wxPyBeginAllowThreads();
9057 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9058
9059 wxPyEndAllowThreads(__tstate);
9060 if (PyErr_Occurred()) SWIG_fail;
9061 }
9062 resultobj = result;
9063 {
9064 if (temp3)
9065 delete arg3;
9066 }
9067 return resultobj;
9068 fail:
9069 {
9070 if (temp3)
9071 delete arg3;
9072 }
9073 return NULL;
9074 }
9075
9076
9077 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9078 PyObject *resultobj;
9079 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9080 wxFontEncoding arg2 ;
9081 wxString const &arg3_defvalue = wxPyEmptyString ;
9082 wxString *arg3 = (wxString *) &arg3_defvalue ;
9083 bool result;
9084 bool temp3 = false ;
9085 PyObject * obj0 = 0 ;
9086 PyObject * obj1 = 0 ;
9087 PyObject * obj2 = 0 ;
9088 char *kwnames[] = {
9089 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9090 };
9091
9092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9094 if (SWIG_arg_fail(1)) SWIG_fail;
9095 {
9096 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9097 if (SWIG_arg_fail(2)) SWIG_fail;
9098 }
9099 if (obj2) {
9100 {
9101 arg3 = wxString_in_helper(obj2);
9102 if (arg3 == NULL) SWIG_fail;
9103 temp3 = true;
9104 }
9105 }
9106 {
9107 PyThreadState* __tstate = wxPyBeginAllowThreads();
9108 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9109
9110 wxPyEndAllowThreads(__tstate);
9111 if (PyErr_Occurred()) SWIG_fail;
9112 }
9113 {
9114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9115 }
9116 {
9117 if (temp3)
9118 delete arg3;
9119 }
9120 return resultobj;
9121 fail:
9122 {
9123 if (temp3)
9124 delete arg3;
9125 }
9126 return NULL;
9127 }
9128
9129
9130 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9131 PyObject *resultobj;
9132 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9133 wxWindow *arg2 = (wxWindow *) 0 ;
9134 PyObject * obj0 = 0 ;
9135 PyObject * obj1 = 0 ;
9136 char *kwnames[] = {
9137 (char *) "self",(char *) "parent", NULL
9138 };
9139
9140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9142 if (SWIG_arg_fail(1)) SWIG_fail;
9143 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9144 if (SWIG_arg_fail(2)) SWIG_fail;
9145 {
9146 PyThreadState* __tstate = wxPyBeginAllowThreads();
9147 (arg1)->SetDialogParent(arg2);
9148
9149 wxPyEndAllowThreads(__tstate);
9150 if (PyErr_Occurred()) SWIG_fail;
9151 }
9152 Py_INCREF(Py_None); resultobj = Py_None;
9153 return resultobj;
9154 fail:
9155 return NULL;
9156 }
9157
9158
9159 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9160 PyObject *resultobj;
9161 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9162 wxString *arg2 = 0 ;
9163 bool temp2 = false ;
9164 PyObject * obj0 = 0 ;
9165 PyObject * obj1 = 0 ;
9166 char *kwnames[] = {
9167 (char *) "self",(char *) "title", NULL
9168 };
9169
9170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9172 if (SWIG_arg_fail(1)) SWIG_fail;
9173 {
9174 arg2 = wxString_in_helper(obj1);
9175 if (arg2 == NULL) SWIG_fail;
9176 temp2 = true;
9177 }
9178 {
9179 PyThreadState* __tstate = wxPyBeginAllowThreads();
9180 (arg1)->SetDialogTitle((wxString const &)*arg2);
9181
9182 wxPyEndAllowThreads(__tstate);
9183 if (PyErr_Occurred()) SWIG_fail;
9184 }
9185 Py_INCREF(Py_None); resultobj = Py_None;
9186 {
9187 if (temp2)
9188 delete arg2;
9189 }
9190 return resultobj;
9191 fail:
9192 {
9193 if (temp2)
9194 delete arg2;
9195 }
9196 return NULL;
9197 }
9198
9199
9200 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9201 PyObject *obj;
9202 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9203 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9204 Py_INCREF(obj);
9205 return Py_BuildValue((char *)"");
9206 }
9207 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9208 PyObject *resultobj;
9209 int arg1 ;
9210 int arg2 ;
9211 int arg3 ;
9212 int arg4 ;
9213 bool arg5 = (bool) false ;
9214 wxString const &arg6_defvalue = wxPyEmptyString ;
9215 wxString *arg6 = (wxString *) &arg6_defvalue ;
9216 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9217 wxFont *result;
9218 bool temp6 = false ;
9219 PyObject * obj0 = 0 ;
9220 PyObject * obj1 = 0 ;
9221 PyObject * obj2 = 0 ;
9222 PyObject * obj3 = 0 ;
9223 PyObject * obj4 = 0 ;
9224 PyObject * obj5 = 0 ;
9225 PyObject * obj6 = 0 ;
9226 char *kwnames[] = {
9227 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9228 };
9229
9230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9231 {
9232 arg1 = (int)(SWIG_As_int(obj0));
9233 if (SWIG_arg_fail(1)) SWIG_fail;
9234 }
9235 {
9236 arg2 = (int)(SWIG_As_int(obj1));
9237 if (SWIG_arg_fail(2)) SWIG_fail;
9238 }
9239 {
9240 arg3 = (int)(SWIG_As_int(obj2));
9241 if (SWIG_arg_fail(3)) SWIG_fail;
9242 }
9243 {
9244 arg4 = (int)(SWIG_As_int(obj3));
9245 if (SWIG_arg_fail(4)) SWIG_fail;
9246 }
9247 if (obj4) {
9248 {
9249 arg5 = (bool)(SWIG_As_bool(obj4));
9250 if (SWIG_arg_fail(5)) SWIG_fail;
9251 }
9252 }
9253 if (obj5) {
9254 {
9255 arg6 = wxString_in_helper(obj5);
9256 if (arg6 == NULL) SWIG_fail;
9257 temp6 = true;
9258 }
9259 }
9260 if (obj6) {
9261 {
9262 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9263 if (SWIG_arg_fail(7)) SWIG_fail;
9264 }
9265 }
9266 {
9267 if (!wxPyCheckForApp()) SWIG_fail;
9268 PyThreadState* __tstate = wxPyBeginAllowThreads();
9269 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9270
9271 wxPyEndAllowThreads(__tstate);
9272 if (PyErr_Occurred()) SWIG_fail;
9273 }
9274 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9275 {
9276 if (temp6)
9277 delete arg6;
9278 }
9279 return resultobj;
9280 fail:
9281 {
9282 if (temp6)
9283 delete arg6;
9284 }
9285 return NULL;
9286 }
9287
9288
9289 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9290 PyObject *resultobj;
9291 wxFont *arg1 = (wxFont *) 0 ;
9292 PyObject * obj0 = 0 ;
9293 char *kwnames[] = {
9294 (char *) "self", NULL
9295 };
9296
9297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9299 if (SWIG_arg_fail(1)) SWIG_fail;
9300 {
9301 PyThreadState* __tstate = wxPyBeginAllowThreads();
9302 delete arg1;
9303
9304 wxPyEndAllowThreads(__tstate);
9305 if (PyErr_Occurred()) SWIG_fail;
9306 }
9307 Py_INCREF(Py_None); resultobj = Py_None;
9308 return resultobj;
9309 fail:
9310 return NULL;
9311 }
9312
9313
9314 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9315 PyObject *resultobj;
9316 wxNativeFontInfo *arg1 = 0 ;
9317 wxFont *result;
9318 PyObject * obj0 = 0 ;
9319 char *kwnames[] = {
9320 (char *) "info", NULL
9321 };
9322
9323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9324 {
9325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9326 if (SWIG_arg_fail(1)) SWIG_fail;
9327 if (arg1 == NULL) {
9328 SWIG_null_ref("wxNativeFontInfo");
9329 }
9330 if (SWIG_arg_fail(1)) SWIG_fail;
9331 }
9332 {
9333 if (!wxPyCheckForApp()) SWIG_fail;
9334 PyThreadState* __tstate = wxPyBeginAllowThreads();
9335 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9336
9337 wxPyEndAllowThreads(__tstate);
9338 if (PyErr_Occurred()) SWIG_fail;
9339 }
9340 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9341 return resultobj;
9342 fail:
9343 return NULL;
9344 }
9345
9346
9347 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9348 PyObject *resultobj;
9349 wxString *arg1 = 0 ;
9350 wxFont *result;
9351 bool temp1 = false ;
9352 PyObject * obj0 = 0 ;
9353 char *kwnames[] = {
9354 (char *) "info", NULL
9355 };
9356
9357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9358 {
9359 arg1 = wxString_in_helper(obj0);
9360 if (arg1 == NULL) SWIG_fail;
9361 temp1 = true;
9362 }
9363 {
9364 if (!wxPyCheckForApp()) SWIG_fail;
9365 PyThreadState* __tstate = wxPyBeginAllowThreads();
9366 result = (wxFont *)new_wxFont((wxString const &)*arg1);
9367
9368 wxPyEndAllowThreads(__tstate);
9369 if (PyErr_Occurred()) SWIG_fail;
9370 }
9371 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9372 {
9373 if (temp1)
9374 delete arg1;
9375 }
9376 return resultobj;
9377 fail:
9378 {
9379 if (temp1)
9380 delete arg1;
9381 }
9382 return NULL;
9383 }
9384
9385
9386 static PyObject *_wrap_new_Font2(PyObject *, PyObject *args, PyObject *kwargs) {
9387 PyObject *resultobj;
9388 int arg1 ;
9389 wxFontFamily arg2 ;
9390 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9391 wxString const &arg4_defvalue = wxPyEmptyString ;
9392 wxString *arg4 = (wxString *) &arg4_defvalue ;
9393 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9394 wxFont *result;
9395 bool temp4 = false ;
9396 PyObject * obj0 = 0 ;
9397 PyObject * obj1 = 0 ;
9398 PyObject * obj2 = 0 ;
9399 PyObject * obj3 = 0 ;
9400 PyObject * obj4 = 0 ;
9401 char *kwnames[] = {
9402 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9403 };
9404
9405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_Font2",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9406 {
9407 arg1 = (int)(SWIG_As_int(obj0));
9408 if (SWIG_arg_fail(1)) SWIG_fail;
9409 }
9410 {
9411 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9412 if (SWIG_arg_fail(2)) SWIG_fail;
9413 }
9414 if (obj2) {
9415 {
9416 arg3 = (int)(SWIG_As_int(obj2));
9417 if (SWIG_arg_fail(3)) SWIG_fail;
9418 }
9419 }
9420 if (obj3) {
9421 {
9422 arg4 = wxString_in_helper(obj3);
9423 if (arg4 == NULL) SWIG_fail;
9424 temp4 = true;
9425 }
9426 }
9427 if (obj4) {
9428 {
9429 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9430 if (SWIG_arg_fail(5)) SWIG_fail;
9431 }
9432 }
9433 {
9434 if (!wxPyCheckForApp()) SWIG_fail;
9435 PyThreadState* __tstate = wxPyBeginAllowThreads();
9436 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9437
9438 wxPyEndAllowThreads(__tstate);
9439 if (PyErr_Occurred()) SWIG_fail;
9440 }
9441 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9442 {
9443 if (temp4)
9444 delete arg4;
9445 }
9446 return resultobj;
9447 fail:
9448 {
9449 if (temp4)
9450 delete arg4;
9451 }
9452 return NULL;
9453 }
9454
9455
9456 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9457 PyObject *resultobj;
9458 wxSize *arg1 = 0 ;
9459 int arg2 ;
9460 int arg3 ;
9461 int arg4 ;
9462 bool arg5 = (bool) false ;
9463 wxString const &arg6_defvalue = wxEmptyString ;
9464 wxString *arg6 = (wxString *) &arg6_defvalue ;
9465 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9466 wxFont *result;
9467 wxSize temp1 ;
9468 bool temp6 = false ;
9469 PyObject * obj0 = 0 ;
9470 PyObject * obj1 = 0 ;
9471 PyObject * obj2 = 0 ;
9472 PyObject * obj3 = 0 ;
9473 PyObject * obj4 = 0 ;
9474 PyObject * obj5 = 0 ;
9475 PyObject * obj6 = 0 ;
9476 char *kwnames[] = {
9477 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
9478 };
9479
9480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9481 {
9482 arg1 = &temp1;
9483 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9484 }
9485 {
9486 arg2 = (int)(SWIG_As_int(obj1));
9487 if (SWIG_arg_fail(2)) SWIG_fail;
9488 }
9489 {
9490 arg3 = (int)(SWIG_As_int(obj2));
9491 if (SWIG_arg_fail(3)) SWIG_fail;
9492 }
9493 {
9494 arg4 = (int)(SWIG_As_int(obj3));
9495 if (SWIG_arg_fail(4)) SWIG_fail;
9496 }
9497 if (obj4) {
9498 {
9499 arg5 = (bool)(SWIG_As_bool(obj4));
9500 if (SWIG_arg_fail(5)) SWIG_fail;
9501 }
9502 }
9503 if (obj5) {
9504 {
9505 arg6 = wxString_in_helper(obj5);
9506 if (arg6 == NULL) SWIG_fail;
9507 temp6 = true;
9508 }
9509 }
9510 if (obj6) {
9511 {
9512 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9513 if (SWIG_arg_fail(7)) SWIG_fail;
9514 }
9515 }
9516 {
9517 if (!wxPyCheckForApp()) SWIG_fail;
9518 PyThreadState* __tstate = wxPyBeginAllowThreads();
9519 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9520
9521 wxPyEndAllowThreads(__tstate);
9522 if (PyErr_Occurred()) SWIG_fail;
9523 }
9524 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9525 {
9526 if (temp6)
9527 delete arg6;
9528 }
9529 return resultobj;
9530 fail:
9531 {
9532 if (temp6)
9533 delete arg6;
9534 }
9535 return NULL;
9536 }
9537
9538
9539 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
9540 PyObject *resultobj;
9541 wxFont *arg1 = (wxFont *) 0 ;
9542 bool result;
9543 PyObject * obj0 = 0 ;
9544 char *kwnames[] = {
9545 (char *) "self", NULL
9546 };
9547
9548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
9549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9550 if (SWIG_arg_fail(1)) SWIG_fail;
9551 {
9552 PyThreadState* __tstate = wxPyBeginAllowThreads();
9553 result = (bool)((wxFont const *)arg1)->Ok();
9554
9555 wxPyEndAllowThreads(__tstate);
9556 if (PyErr_Occurred()) SWIG_fail;
9557 }
9558 {
9559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9560 }
9561 return resultobj;
9562 fail:
9563 return NULL;
9564 }
9565
9566
9567 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9568 PyObject *resultobj;
9569 wxFont *arg1 = (wxFont *) 0 ;
9570 wxFont *arg2 = (wxFont *) 0 ;
9571 bool result;
9572 PyObject * obj0 = 0 ;
9573 PyObject * obj1 = 0 ;
9574 char *kwnames[] = {
9575 (char *) "self",(char *) "other", NULL
9576 };
9577
9578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
9579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9580 if (SWIG_arg_fail(1)) SWIG_fail;
9581 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9582 if (SWIG_arg_fail(2)) SWIG_fail;
9583 {
9584 PyThreadState* __tstate = wxPyBeginAllowThreads();
9585 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
9586
9587 wxPyEndAllowThreads(__tstate);
9588 if (PyErr_Occurred()) SWIG_fail;
9589 }
9590 {
9591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9592 }
9593 return resultobj;
9594 fail:
9595 return NULL;
9596 }
9597
9598
9599 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9600 PyObject *resultobj;
9601 wxFont *arg1 = (wxFont *) 0 ;
9602 wxFont *arg2 = (wxFont *) 0 ;
9603 bool result;
9604 PyObject * obj0 = 0 ;
9605 PyObject * obj1 = 0 ;
9606 char *kwnames[] = {
9607 (char *) "self",(char *) "other", NULL
9608 };
9609
9610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
9611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9612 if (SWIG_arg_fail(1)) SWIG_fail;
9613 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9614 if (SWIG_arg_fail(2)) SWIG_fail;
9615 {
9616 PyThreadState* __tstate = wxPyBeginAllowThreads();
9617 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
9618
9619 wxPyEndAllowThreads(__tstate);
9620 if (PyErr_Occurred()) SWIG_fail;
9621 }
9622 {
9623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9624 }
9625 return resultobj;
9626 fail:
9627 return NULL;
9628 }
9629
9630
9631 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9632 PyObject *resultobj;
9633 wxFont *arg1 = (wxFont *) 0 ;
9634 int result;
9635 PyObject * obj0 = 0 ;
9636 char *kwnames[] = {
9637 (char *) "self", NULL
9638 };
9639
9640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
9641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9642 if (SWIG_arg_fail(1)) SWIG_fail;
9643 {
9644 PyThreadState* __tstate = wxPyBeginAllowThreads();
9645 result = (int)((wxFont const *)arg1)->GetPointSize();
9646
9647 wxPyEndAllowThreads(__tstate);
9648 if (PyErr_Occurred()) SWIG_fail;
9649 }
9650 {
9651 resultobj = SWIG_From_int((int)(result));
9652 }
9653 return resultobj;
9654 fail:
9655 return NULL;
9656 }
9657
9658
9659 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9660 PyObject *resultobj;
9661 wxFont *arg1 = (wxFont *) 0 ;
9662 wxSize result;
9663 PyObject * obj0 = 0 ;
9664 char *kwnames[] = {
9665 (char *) "self", NULL
9666 };
9667
9668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
9669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9670 if (SWIG_arg_fail(1)) SWIG_fail;
9671 {
9672 PyThreadState* __tstate = wxPyBeginAllowThreads();
9673 result = ((wxFont const *)arg1)->GetPixelSize();
9674
9675 wxPyEndAllowThreads(__tstate);
9676 if (PyErr_Occurred()) SWIG_fail;
9677 }
9678 {
9679 wxSize * resultptr;
9680 resultptr = new wxSize((wxSize &)(result));
9681 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
9682 }
9683 return resultobj;
9684 fail:
9685 return NULL;
9686 }
9687
9688
9689 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
9690 PyObject *resultobj;
9691 wxFont *arg1 = (wxFont *) 0 ;
9692 bool result;
9693 PyObject * obj0 = 0 ;
9694 char *kwnames[] = {
9695 (char *) "self", NULL
9696 };
9697
9698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
9699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9700 if (SWIG_arg_fail(1)) SWIG_fail;
9701 {
9702 PyThreadState* __tstate = wxPyBeginAllowThreads();
9703 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
9704
9705 wxPyEndAllowThreads(__tstate);
9706 if (PyErr_Occurred()) SWIG_fail;
9707 }
9708 {
9709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9710 }
9711 return resultobj;
9712 fail:
9713 return NULL;
9714 }
9715
9716
9717 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
9718 PyObject *resultobj;
9719 wxFont *arg1 = (wxFont *) 0 ;
9720 int result;
9721 PyObject * obj0 = 0 ;
9722 char *kwnames[] = {
9723 (char *) "self", NULL
9724 };
9725
9726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
9727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9728 if (SWIG_arg_fail(1)) SWIG_fail;
9729 {
9730 PyThreadState* __tstate = wxPyBeginAllowThreads();
9731 result = (int)((wxFont const *)arg1)->GetFamily();
9732
9733 wxPyEndAllowThreads(__tstate);
9734 if (PyErr_Occurred()) SWIG_fail;
9735 }
9736 {
9737 resultobj = SWIG_From_int((int)(result));
9738 }
9739 return resultobj;
9740 fail:
9741 return NULL;
9742 }
9743
9744
9745 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
9746 PyObject *resultobj;
9747 wxFont *arg1 = (wxFont *) 0 ;
9748 int result;
9749 PyObject * obj0 = 0 ;
9750 char *kwnames[] = {
9751 (char *) "self", NULL
9752 };
9753
9754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
9755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9756 if (SWIG_arg_fail(1)) SWIG_fail;
9757 {
9758 PyThreadState* __tstate = wxPyBeginAllowThreads();
9759 result = (int)((wxFont const *)arg1)->GetStyle();
9760
9761 wxPyEndAllowThreads(__tstate);
9762 if (PyErr_Occurred()) SWIG_fail;
9763 }
9764 {
9765 resultobj = SWIG_From_int((int)(result));
9766 }
9767 return resultobj;
9768 fail:
9769 return NULL;
9770 }
9771
9772
9773 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
9774 PyObject *resultobj;
9775 wxFont *arg1 = (wxFont *) 0 ;
9776 int result;
9777 PyObject * obj0 = 0 ;
9778 char *kwnames[] = {
9779 (char *) "self", NULL
9780 };
9781
9782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
9783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9784 if (SWIG_arg_fail(1)) SWIG_fail;
9785 {
9786 PyThreadState* __tstate = wxPyBeginAllowThreads();
9787 result = (int)((wxFont const *)arg1)->GetWeight();
9788
9789 wxPyEndAllowThreads(__tstate);
9790 if (PyErr_Occurred()) SWIG_fail;
9791 }
9792 {
9793 resultobj = SWIG_From_int((int)(result));
9794 }
9795 return resultobj;
9796 fail:
9797 return NULL;
9798 }
9799
9800
9801 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
9802 PyObject *resultobj;
9803 wxFont *arg1 = (wxFont *) 0 ;
9804 bool result;
9805 PyObject * obj0 = 0 ;
9806 char *kwnames[] = {
9807 (char *) "self", NULL
9808 };
9809
9810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
9811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9812 if (SWIG_arg_fail(1)) SWIG_fail;
9813 {
9814 PyThreadState* __tstate = wxPyBeginAllowThreads();
9815 result = (bool)((wxFont const *)arg1)->GetUnderlined();
9816
9817 wxPyEndAllowThreads(__tstate);
9818 if (PyErr_Occurred()) SWIG_fail;
9819 }
9820 {
9821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9822 }
9823 return resultobj;
9824 fail:
9825 return NULL;
9826 }
9827
9828
9829 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
9830 PyObject *resultobj;
9831 wxFont *arg1 = (wxFont *) 0 ;
9832 wxString result;
9833 PyObject * obj0 = 0 ;
9834 char *kwnames[] = {
9835 (char *) "self", NULL
9836 };
9837
9838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
9839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9840 if (SWIG_arg_fail(1)) SWIG_fail;
9841 {
9842 PyThreadState* __tstate = wxPyBeginAllowThreads();
9843 result = ((wxFont const *)arg1)->GetFaceName();
9844
9845 wxPyEndAllowThreads(__tstate);
9846 if (PyErr_Occurred()) SWIG_fail;
9847 }
9848 {
9849 #if wxUSE_UNICODE
9850 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9851 #else
9852 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9853 #endif
9854 }
9855 return resultobj;
9856 fail:
9857 return NULL;
9858 }
9859
9860
9861 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9862 PyObject *resultobj;
9863 wxFont *arg1 = (wxFont *) 0 ;
9864 wxFontEncoding result;
9865 PyObject * obj0 = 0 ;
9866 char *kwnames[] = {
9867 (char *) "self", NULL
9868 };
9869
9870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
9871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9872 if (SWIG_arg_fail(1)) SWIG_fail;
9873 {
9874 PyThreadState* __tstate = wxPyBeginAllowThreads();
9875 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
9876
9877 wxPyEndAllowThreads(__tstate);
9878 if (PyErr_Occurred()) SWIG_fail;
9879 }
9880 resultobj = SWIG_From_int((result));
9881 return resultobj;
9882 fail:
9883 return NULL;
9884 }
9885
9886
9887 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9888 PyObject *resultobj;
9889 wxFont *arg1 = (wxFont *) 0 ;
9890 wxNativeFontInfo *result;
9891 PyObject * obj0 = 0 ;
9892 char *kwnames[] = {
9893 (char *) "self", NULL
9894 };
9895
9896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
9897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9898 if (SWIG_arg_fail(1)) SWIG_fail;
9899 {
9900 PyThreadState* __tstate = wxPyBeginAllowThreads();
9901 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
9902
9903 wxPyEndAllowThreads(__tstate);
9904 if (PyErr_Occurred()) SWIG_fail;
9905 }
9906 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
9907 return resultobj;
9908 fail:
9909 return NULL;
9910 }
9911
9912
9913 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
9914 PyObject *resultobj;
9915 wxFont *arg1 = (wxFont *) 0 ;
9916 bool result;
9917 PyObject * obj0 = 0 ;
9918 char *kwnames[] = {
9919 (char *) "self", NULL
9920 };
9921
9922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
9923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9924 if (SWIG_arg_fail(1)) SWIG_fail;
9925 {
9926 PyThreadState* __tstate = wxPyBeginAllowThreads();
9927 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
9928
9929 wxPyEndAllowThreads(__tstate);
9930 if (PyErr_Occurred()) SWIG_fail;
9931 }
9932 {
9933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9934 }
9935 return resultobj;
9936 fail:
9937 return NULL;
9938 }
9939
9940
9941 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
9942 PyObject *resultobj;
9943 wxFont *arg1 = (wxFont *) 0 ;
9944 wxString result;
9945 PyObject * obj0 = 0 ;
9946 char *kwnames[] = {
9947 (char *) "self", NULL
9948 };
9949
9950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
9951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9952 if (SWIG_arg_fail(1)) SWIG_fail;
9953 {
9954 PyThreadState* __tstate = wxPyBeginAllowThreads();
9955 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
9956
9957 wxPyEndAllowThreads(__tstate);
9958 if (PyErr_Occurred()) SWIG_fail;
9959 }
9960 {
9961 #if wxUSE_UNICODE
9962 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9963 #else
9964 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9965 #endif
9966 }
9967 return resultobj;
9968 fail:
9969 return NULL;
9970 }
9971
9972
9973 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
9974 PyObject *resultobj;
9975 wxFont *arg1 = (wxFont *) 0 ;
9976 wxString result;
9977 PyObject * obj0 = 0 ;
9978 char *kwnames[] = {
9979 (char *) "self", NULL
9980 };
9981
9982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
9983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9984 if (SWIG_arg_fail(1)) SWIG_fail;
9985 {
9986 PyThreadState* __tstate = wxPyBeginAllowThreads();
9987 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
9988
9989 wxPyEndAllowThreads(__tstate);
9990 if (PyErr_Occurred()) SWIG_fail;
9991 }
9992 {
9993 #if wxUSE_UNICODE
9994 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9995 #else
9996 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9997 #endif
9998 }
9999 return resultobj;
10000 fail:
10001 return NULL;
10002 }
10003
10004
10005 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10006 PyObject *resultobj;
10007 wxFont *arg1 = (wxFont *) 0 ;
10008 int arg2 ;
10009 PyObject * obj0 = 0 ;
10010 PyObject * obj1 = 0 ;
10011 char *kwnames[] = {
10012 (char *) "self",(char *) "pointSize", NULL
10013 };
10014
10015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
10016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10017 if (SWIG_arg_fail(1)) SWIG_fail;
10018 {
10019 arg2 = (int)(SWIG_As_int(obj1));
10020 if (SWIG_arg_fail(2)) SWIG_fail;
10021 }
10022 {
10023 PyThreadState* __tstate = wxPyBeginAllowThreads();
10024 (arg1)->SetPointSize(arg2);
10025
10026 wxPyEndAllowThreads(__tstate);
10027 if (PyErr_Occurred()) SWIG_fail;
10028 }
10029 Py_INCREF(Py_None); resultobj = Py_None;
10030 return resultobj;
10031 fail:
10032 return NULL;
10033 }
10034
10035
10036 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10037 PyObject *resultobj;
10038 wxFont *arg1 = (wxFont *) 0 ;
10039 wxSize *arg2 = 0 ;
10040 wxSize temp2 ;
10041 PyObject * obj0 = 0 ;
10042 PyObject * obj1 = 0 ;
10043 char *kwnames[] = {
10044 (char *) "self",(char *) "pixelSize", NULL
10045 };
10046
10047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10049 if (SWIG_arg_fail(1)) SWIG_fail;
10050 {
10051 arg2 = &temp2;
10052 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10053 }
10054 {
10055 PyThreadState* __tstate = wxPyBeginAllowThreads();
10056 (arg1)->SetPixelSize((wxSize const &)*arg2);
10057
10058 wxPyEndAllowThreads(__tstate);
10059 if (PyErr_Occurred()) SWIG_fail;
10060 }
10061 Py_INCREF(Py_None); resultobj = Py_None;
10062 return resultobj;
10063 fail:
10064 return NULL;
10065 }
10066
10067
10068 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10069 PyObject *resultobj;
10070 wxFont *arg1 = (wxFont *) 0 ;
10071 int arg2 ;
10072 PyObject * obj0 = 0 ;
10073 PyObject * obj1 = 0 ;
10074 char *kwnames[] = {
10075 (char *) "self",(char *) "family", NULL
10076 };
10077
10078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10080 if (SWIG_arg_fail(1)) SWIG_fail;
10081 {
10082 arg2 = (int)(SWIG_As_int(obj1));
10083 if (SWIG_arg_fail(2)) SWIG_fail;
10084 }
10085 {
10086 PyThreadState* __tstate = wxPyBeginAllowThreads();
10087 (arg1)->SetFamily(arg2);
10088
10089 wxPyEndAllowThreads(__tstate);
10090 if (PyErr_Occurred()) SWIG_fail;
10091 }
10092 Py_INCREF(Py_None); resultobj = Py_None;
10093 return resultobj;
10094 fail:
10095 return NULL;
10096 }
10097
10098
10099 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10100 PyObject *resultobj;
10101 wxFont *arg1 = (wxFont *) 0 ;
10102 int arg2 ;
10103 PyObject * obj0 = 0 ;
10104 PyObject * obj1 = 0 ;
10105 char *kwnames[] = {
10106 (char *) "self",(char *) "style", NULL
10107 };
10108
10109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10111 if (SWIG_arg_fail(1)) SWIG_fail;
10112 {
10113 arg2 = (int)(SWIG_As_int(obj1));
10114 if (SWIG_arg_fail(2)) SWIG_fail;
10115 }
10116 {
10117 PyThreadState* __tstate = wxPyBeginAllowThreads();
10118 (arg1)->SetStyle(arg2);
10119
10120 wxPyEndAllowThreads(__tstate);
10121 if (PyErr_Occurred()) SWIG_fail;
10122 }
10123 Py_INCREF(Py_None); resultobj = Py_None;
10124 return resultobj;
10125 fail:
10126 return NULL;
10127 }
10128
10129
10130 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10131 PyObject *resultobj;
10132 wxFont *arg1 = (wxFont *) 0 ;
10133 int arg2 ;
10134 PyObject * obj0 = 0 ;
10135 PyObject * obj1 = 0 ;
10136 char *kwnames[] = {
10137 (char *) "self",(char *) "weight", NULL
10138 };
10139
10140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10142 if (SWIG_arg_fail(1)) SWIG_fail;
10143 {
10144 arg2 = (int)(SWIG_As_int(obj1));
10145 if (SWIG_arg_fail(2)) SWIG_fail;
10146 }
10147 {
10148 PyThreadState* __tstate = wxPyBeginAllowThreads();
10149 (arg1)->SetWeight(arg2);
10150
10151 wxPyEndAllowThreads(__tstate);
10152 if (PyErr_Occurred()) SWIG_fail;
10153 }
10154 Py_INCREF(Py_None); resultobj = Py_None;
10155 return resultobj;
10156 fail:
10157 return NULL;
10158 }
10159
10160
10161 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10162 PyObject *resultobj;
10163 wxFont *arg1 = (wxFont *) 0 ;
10164 wxString *arg2 = 0 ;
10165 bool temp2 = false ;
10166 PyObject * obj0 = 0 ;
10167 PyObject * obj1 = 0 ;
10168 char *kwnames[] = {
10169 (char *) "self",(char *) "faceName", NULL
10170 };
10171
10172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10174 if (SWIG_arg_fail(1)) SWIG_fail;
10175 {
10176 arg2 = wxString_in_helper(obj1);
10177 if (arg2 == NULL) SWIG_fail;
10178 temp2 = true;
10179 }
10180 {
10181 PyThreadState* __tstate = wxPyBeginAllowThreads();
10182 (arg1)->SetFaceName((wxString const &)*arg2);
10183
10184 wxPyEndAllowThreads(__tstate);
10185 if (PyErr_Occurred()) SWIG_fail;
10186 }
10187 Py_INCREF(Py_None); resultobj = Py_None;
10188 {
10189 if (temp2)
10190 delete arg2;
10191 }
10192 return resultobj;
10193 fail:
10194 {
10195 if (temp2)
10196 delete arg2;
10197 }
10198 return NULL;
10199 }
10200
10201
10202 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10203 PyObject *resultobj;
10204 wxFont *arg1 = (wxFont *) 0 ;
10205 bool arg2 ;
10206 PyObject * obj0 = 0 ;
10207 PyObject * obj1 = 0 ;
10208 char *kwnames[] = {
10209 (char *) "self",(char *) "underlined", NULL
10210 };
10211
10212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10214 if (SWIG_arg_fail(1)) SWIG_fail;
10215 {
10216 arg2 = (bool)(SWIG_As_bool(obj1));
10217 if (SWIG_arg_fail(2)) SWIG_fail;
10218 }
10219 {
10220 PyThreadState* __tstate = wxPyBeginAllowThreads();
10221 (arg1)->SetUnderlined(arg2);
10222
10223 wxPyEndAllowThreads(__tstate);
10224 if (PyErr_Occurred()) SWIG_fail;
10225 }
10226 Py_INCREF(Py_None); resultobj = Py_None;
10227 return resultobj;
10228 fail:
10229 return NULL;
10230 }
10231
10232
10233 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10234 PyObject *resultobj;
10235 wxFont *arg1 = (wxFont *) 0 ;
10236 wxFontEncoding arg2 ;
10237 PyObject * obj0 = 0 ;
10238 PyObject * obj1 = 0 ;
10239 char *kwnames[] = {
10240 (char *) "self",(char *) "encoding", NULL
10241 };
10242
10243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10245 if (SWIG_arg_fail(1)) SWIG_fail;
10246 {
10247 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10248 if (SWIG_arg_fail(2)) SWIG_fail;
10249 }
10250 {
10251 PyThreadState* __tstate = wxPyBeginAllowThreads();
10252 (arg1)->SetEncoding((wxFontEncoding )arg2);
10253
10254 wxPyEndAllowThreads(__tstate);
10255 if (PyErr_Occurred()) SWIG_fail;
10256 }
10257 Py_INCREF(Py_None); resultobj = Py_None;
10258 return resultobj;
10259 fail:
10260 return NULL;
10261 }
10262
10263
10264 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10265 PyObject *resultobj;
10266 wxFont *arg1 = (wxFont *) 0 ;
10267 wxNativeFontInfo *arg2 = 0 ;
10268 PyObject * obj0 = 0 ;
10269 PyObject * obj1 = 0 ;
10270 char *kwnames[] = {
10271 (char *) "self",(char *) "info", NULL
10272 };
10273
10274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10276 if (SWIG_arg_fail(1)) SWIG_fail;
10277 {
10278 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10279 if (SWIG_arg_fail(2)) SWIG_fail;
10280 if (arg2 == NULL) {
10281 SWIG_null_ref("wxNativeFontInfo");
10282 }
10283 if (SWIG_arg_fail(2)) SWIG_fail;
10284 }
10285 {
10286 PyThreadState* __tstate = wxPyBeginAllowThreads();
10287 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10288
10289 wxPyEndAllowThreads(__tstate);
10290 if (PyErr_Occurred()) SWIG_fail;
10291 }
10292 Py_INCREF(Py_None); resultobj = Py_None;
10293 return resultobj;
10294 fail:
10295 return NULL;
10296 }
10297
10298
10299 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10300 PyObject *resultobj;
10301 wxFont *arg1 = (wxFont *) 0 ;
10302 wxString *arg2 = 0 ;
10303 bool temp2 = false ;
10304 PyObject * obj0 = 0 ;
10305 PyObject * obj1 = 0 ;
10306 char *kwnames[] = {
10307 (char *) "self",(char *) "info", NULL
10308 };
10309
10310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10312 if (SWIG_arg_fail(1)) SWIG_fail;
10313 {
10314 arg2 = wxString_in_helper(obj1);
10315 if (arg2 == NULL) SWIG_fail;
10316 temp2 = true;
10317 }
10318 {
10319 PyThreadState* __tstate = wxPyBeginAllowThreads();
10320 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10321
10322 wxPyEndAllowThreads(__tstate);
10323 if (PyErr_Occurred()) SWIG_fail;
10324 }
10325 Py_INCREF(Py_None); resultobj = Py_None;
10326 {
10327 if (temp2)
10328 delete arg2;
10329 }
10330 return resultobj;
10331 fail:
10332 {
10333 if (temp2)
10334 delete arg2;
10335 }
10336 return NULL;
10337 }
10338
10339
10340 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10341 PyObject *resultobj;
10342 wxFont *arg1 = (wxFont *) 0 ;
10343 wxString *arg2 = 0 ;
10344 bool temp2 = false ;
10345 PyObject * obj0 = 0 ;
10346 PyObject * obj1 = 0 ;
10347 char *kwnames[] = {
10348 (char *) "self",(char *) "info", NULL
10349 };
10350
10351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10353 if (SWIG_arg_fail(1)) SWIG_fail;
10354 {
10355 arg2 = wxString_in_helper(obj1);
10356 if (arg2 == NULL) SWIG_fail;
10357 temp2 = true;
10358 }
10359 {
10360 PyThreadState* __tstate = wxPyBeginAllowThreads();
10361 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
10362
10363 wxPyEndAllowThreads(__tstate);
10364 if (PyErr_Occurred()) SWIG_fail;
10365 }
10366 Py_INCREF(Py_None); resultobj = Py_None;
10367 {
10368 if (temp2)
10369 delete arg2;
10370 }
10371 return resultobj;
10372 fail:
10373 {
10374 if (temp2)
10375 delete arg2;
10376 }
10377 return NULL;
10378 }
10379
10380
10381 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
10382 PyObject *resultobj;
10383 wxFont *arg1 = (wxFont *) 0 ;
10384 wxString result;
10385 PyObject * obj0 = 0 ;
10386 char *kwnames[] = {
10387 (char *) "self", NULL
10388 };
10389
10390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
10391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10392 if (SWIG_arg_fail(1)) SWIG_fail;
10393 {
10394 PyThreadState* __tstate = wxPyBeginAllowThreads();
10395 result = ((wxFont const *)arg1)->GetFamilyString();
10396
10397 wxPyEndAllowThreads(__tstate);
10398 if (PyErr_Occurred()) SWIG_fail;
10399 }
10400 {
10401 #if wxUSE_UNICODE
10402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10403 #else
10404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10405 #endif
10406 }
10407 return resultobj;
10408 fail:
10409 return NULL;
10410 }
10411
10412
10413 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
10414 PyObject *resultobj;
10415 wxFont *arg1 = (wxFont *) 0 ;
10416 wxString result;
10417 PyObject * obj0 = 0 ;
10418 char *kwnames[] = {
10419 (char *) "self", NULL
10420 };
10421
10422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
10423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10424 if (SWIG_arg_fail(1)) SWIG_fail;
10425 {
10426 PyThreadState* __tstate = wxPyBeginAllowThreads();
10427 result = ((wxFont const *)arg1)->GetStyleString();
10428
10429 wxPyEndAllowThreads(__tstate);
10430 if (PyErr_Occurred()) SWIG_fail;
10431 }
10432 {
10433 #if wxUSE_UNICODE
10434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10435 #else
10436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10437 #endif
10438 }
10439 return resultobj;
10440 fail:
10441 return NULL;
10442 }
10443
10444
10445 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
10446 PyObject *resultobj;
10447 wxFont *arg1 = (wxFont *) 0 ;
10448 wxString result;
10449 PyObject * obj0 = 0 ;
10450 char *kwnames[] = {
10451 (char *) "self", NULL
10452 };
10453
10454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
10455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10456 if (SWIG_arg_fail(1)) SWIG_fail;
10457 {
10458 PyThreadState* __tstate = wxPyBeginAllowThreads();
10459 result = ((wxFont const *)arg1)->GetWeightString();
10460
10461 wxPyEndAllowThreads(__tstate);
10462 if (PyErr_Occurred()) SWIG_fail;
10463 }
10464 {
10465 #if wxUSE_UNICODE
10466 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10467 #else
10468 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10469 #endif
10470 }
10471 return resultobj;
10472 fail:
10473 return NULL;
10474 }
10475
10476
10477 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10478 PyObject *resultobj;
10479 wxFont *arg1 = (wxFont *) 0 ;
10480 bool arg2 = (bool) true ;
10481 PyObject * obj0 = 0 ;
10482 PyObject * obj1 = 0 ;
10483 char *kwnames[] = {
10484 (char *) "self",(char *) "no", NULL
10485 };
10486
10487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
10488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10489 if (SWIG_arg_fail(1)) SWIG_fail;
10490 if (obj1) {
10491 {
10492 arg2 = (bool)(SWIG_As_bool(obj1));
10493 if (SWIG_arg_fail(2)) SWIG_fail;
10494 }
10495 }
10496 {
10497 PyThreadState* __tstate = wxPyBeginAllowThreads();
10498 (arg1)->SetNoAntiAliasing(arg2);
10499
10500 wxPyEndAllowThreads(__tstate);
10501 if (PyErr_Occurred()) SWIG_fail;
10502 }
10503 Py_INCREF(Py_None); resultobj = Py_None;
10504 return resultobj;
10505 fail:
10506 return NULL;
10507 }
10508
10509
10510 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10511 PyObject *resultobj;
10512 wxFont *arg1 = (wxFont *) 0 ;
10513 bool result;
10514 PyObject * obj0 = 0 ;
10515 char *kwnames[] = {
10516 (char *) "self", NULL
10517 };
10518
10519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
10520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10521 if (SWIG_arg_fail(1)) SWIG_fail;
10522 {
10523 PyThreadState* __tstate = wxPyBeginAllowThreads();
10524 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
10525
10526 wxPyEndAllowThreads(__tstate);
10527 if (PyErr_Occurred()) SWIG_fail;
10528 }
10529 {
10530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10531 }
10532 return resultobj;
10533 fail:
10534 return NULL;
10535 }
10536
10537
10538 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10539 PyObject *resultobj;
10540 wxFontEncoding result;
10541 char *kwnames[] = {
10542 NULL
10543 };
10544
10545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
10546 {
10547 if (!wxPyCheckForApp()) SWIG_fail;
10548 PyThreadState* __tstate = wxPyBeginAllowThreads();
10549 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
10550
10551 wxPyEndAllowThreads(__tstate);
10552 if (PyErr_Occurred()) SWIG_fail;
10553 }
10554 resultobj = SWIG_From_int((result));
10555 return resultobj;
10556 fail:
10557 return NULL;
10558 }
10559
10560
10561 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10562 PyObject *resultobj;
10563 wxFontEncoding arg1 ;
10564 PyObject * obj0 = 0 ;
10565 char *kwnames[] = {
10566 (char *) "encoding", NULL
10567 };
10568
10569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
10570 {
10571 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
10572 if (SWIG_arg_fail(1)) SWIG_fail;
10573 }
10574 {
10575 if (!wxPyCheckForApp()) SWIG_fail;
10576 PyThreadState* __tstate = wxPyBeginAllowThreads();
10577 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
10578
10579 wxPyEndAllowThreads(__tstate);
10580 if (PyErr_Occurred()) SWIG_fail;
10581 }
10582 Py_INCREF(Py_None); resultobj = Py_None;
10583 return resultobj;
10584 fail:
10585 return NULL;
10586 }
10587
10588
10589 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
10590 PyObject *obj;
10591 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10592 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
10593 Py_INCREF(obj);
10594 return Py_BuildValue((char *)"");
10595 }
10596 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10597 PyObject *resultobj;
10598 wxPyFontEnumerator *result;
10599 char *kwnames[] = {
10600 NULL
10601 };
10602
10603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
10604 {
10605 if (!wxPyCheckForApp()) SWIG_fail;
10606 PyThreadState* __tstate = wxPyBeginAllowThreads();
10607 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
10608
10609 wxPyEndAllowThreads(__tstate);
10610 if (PyErr_Occurred()) SWIG_fail;
10611 }
10612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
10613 return resultobj;
10614 fail:
10615 return NULL;
10616 }
10617
10618
10619 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10620 PyObject *resultobj;
10621 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10622 PyObject * obj0 = 0 ;
10623 char *kwnames[] = {
10624 (char *) "self", NULL
10625 };
10626
10627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
10628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10629 if (SWIG_arg_fail(1)) SWIG_fail;
10630 {
10631 PyThreadState* __tstate = wxPyBeginAllowThreads();
10632 delete arg1;
10633
10634 wxPyEndAllowThreads(__tstate);
10635 if (PyErr_Occurred()) SWIG_fail;
10636 }
10637 Py_INCREF(Py_None); resultobj = Py_None;
10638 return resultobj;
10639 fail:
10640 return NULL;
10641 }
10642
10643
10644 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10645 PyObject *resultobj;
10646 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10647 PyObject *arg2 = (PyObject *) 0 ;
10648 PyObject *arg3 = (PyObject *) 0 ;
10649 bool arg4 ;
10650 PyObject * obj0 = 0 ;
10651 PyObject * obj1 = 0 ;
10652 PyObject * obj2 = 0 ;
10653 PyObject * obj3 = 0 ;
10654 char *kwnames[] = {
10655 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10656 };
10657
10658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10660 if (SWIG_arg_fail(1)) SWIG_fail;
10661 arg2 = obj1;
10662 arg3 = obj2;
10663 {
10664 arg4 = (bool)(SWIG_As_bool(obj3));
10665 if (SWIG_arg_fail(4)) SWIG_fail;
10666 }
10667 {
10668 PyThreadState* __tstate = wxPyBeginAllowThreads();
10669 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10670
10671 wxPyEndAllowThreads(__tstate);
10672 if (PyErr_Occurred()) SWIG_fail;
10673 }
10674 Py_INCREF(Py_None); resultobj = Py_None;
10675 return resultobj;
10676 fail:
10677 return NULL;
10678 }
10679
10680
10681 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10682 PyObject *resultobj;
10683 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10684 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
10685 bool arg3 = (bool) false ;
10686 bool result;
10687 PyObject * obj0 = 0 ;
10688 PyObject * obj1 = 0 ;
10689 PyObject * obj2 = 0 ;
10690 char *kwnames[] = {
10691 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
10692 };
10693
10694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
10695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10696 if (SWIG_arg_fail(1)) SWIG_fail;
10697 if (obj1) {
10698 {
10699 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10700 if (SWIG_arg_fail(2)) SWIG_fail;
10701 }
10702 }
10703 if (obj2) {
10704 {
10705 arg3 = (bool)(SWIG_As_bool(obj2));
10706 if (SWIG_arg_fail(3)) SWIG_fail;
10707 }
10708 }
10709 {
10710 PyThreadState* __tstate = wxPyBeginAllowThreads();
10711 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
10712
10713 wxPyEndAllowThreads(__tstate);
10714 if (PyErr_Occurred()) SWIG_fail;
10715 }
10716 {
10717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10718 }
10719 return resultobj;
10720 fail:
10721 return NULL;
10722 }
10723
10724
10725 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10726 PyObject *resultobj;
10727 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10728 wxString const &arg2_defvalue = wxPyEmptyString ;
10729 wxString *arg2 = (wxString *) &arg2_defvalue ;
10730 bool result;
10731 bool temp2 = false ;
10732 PyObject * obj0 = 0 ;
10733 PyObject * obj1 = 0 ;
10734 char *kwnames[] = {
10735 (char *) "self",(char *) "facename", NULL
10736 };
10737
10738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
10739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10740 if (SWIG_arg_fail(1)) SWIG_fail;
10741 if (obj1) {
10742 {
10743 arg2 = wxString_in_helper(obj1);
10744 if (arg2 == NULL) SWIG_fail;
10745 temp2 = true;
10746 }
10747 }
10748 {
10749 PyThreadState* __tstate = wxPyBeginAllowThreads();
10750 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
10751
10752 wxPyEndAllowThreads(__tstate);
10753 if (PyErr_Occurred()) SWIG_fail;
10754 }
10755 {
10756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10757 }
10758 {
10759 if (temp2)
10760 delete arg2;
10761 }
10762 return resultobj;
10763 fail:
10764 {
10765 if (temp2)
10766 delete arg2;
10767 }
10768 return NULL;
10769 }
10770
10771
10772 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10773 PyObject *resultobj;
10774 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10775 PyObject *result;
10776 PyObject * obj0 = 0 ;
10777 char *kwnames[] = {
10778 (char *) "self", NULL
10779 };
10780
10781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
10782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10783 if (SWIG_arg_fail(1)) SWIG_fail;
10784 {
10785 PyThreadState* __tstate = wxPyBeginAllowThreads();
10786 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
10787
10788 wxPyEndAllowThreads(__tstate);
10789 if (PyErr_Occurred()) SWIG_fail;
10790 }
10791 resultobj = result;
10792 return resultobj;
10793 fail:
10794 return NULL;
10795 }
10796
10797
10798 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10799 PyObject *resultobj;
10800 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10801 PyObject *result;
10802 PyObject * obj0 = 0 ;
10803 char *kwnames[] = {
10804 (char *) "self", NULL
10805 };
10806
10807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
10808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10809 if (SWIG_arg_fail(1)) SWIG_fail;
10810 {
10811 PyThreadState* __tstate = wxPyBeginAllowThreads();
10812 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
10813
10814 wxPyEndAllowThreads(__tstate);
10815 if (PyErr_Occurred()) SWIG_fail;
10816 }
10817 resultobj = result;
10818 return resultobj;
10819 fail:
10820 return NULL;
10821 }
10822
10823
10824 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
10825 PyObject *obj;
10826 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10827 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
10828 Py_INCREF(obj);
10829 return Py_BuildValue((char *)"");
10830 }
10831 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
10832 PyObject *resultobj;
10833 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10834 int arg2 ;
10835 PyObject * obj0 = 0 ;
10836 PyObject * obj1 = 0 ;
10837 char *kwnames[] = {
10838 (char *) "self",(char *) "Language", NULL
10839 };
10840
10841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
10842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10843 if (SWIG_arg_fail(1)) SWIG_fail;
10844 {
10845 arg2 = (int)(SWIG_As_int(obj1));
10846 if (SWIG_arg_fail(2)) SWIG_fail;
10847 }
10848 if (arg1) (arg1)->Language = arg2;
10849
10850 Py_INCREF(Py_None); resultobj = Py_None;
10851 return resultobj;
10852 fail:
10853 return NULL;
10854 }
10855
10856
10857 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
10858 PyObject *resultobj;
10859 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10860 int result;
10861 PyObject * obj0 = 0 ;
10862 char *kwnames[] = {
10863 (char *) "self", NULL
10864 };
10865
10866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
10867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10868 if (SWIG_arg_fail(1)) SWIG_fail;
10869 result = (int) ((arg1)->Language);
10870
10871 {
10872 resultobj = SWIG_From_int((int)(result));
10873 }
10874 return resultobj;
10875 fail:
10876 return NULL;
10877 }
10878
10879
10880 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
10881 PyObject *resultobj;
10882 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10883 wxString *arg2 = (wxString *) 0 ;
10884 bool temp2 = false ;
10885 PyObject * obj0 = 0 ;
10886 PyObject * obj1 = 0 ;
10887 char *kwnames[] = {
10888 (char *) "self",(char *) "CanonicalName", NULL
10889 };
10890
10891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
10892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10893 if (SWIG_arg_fail(1)) SWIG_fail;
10894 {
10895 arg2 = wxString_in_helper(obj1);
10896 if (arg2 == NULL) SWIG_fail;
10897 temp2 = true;
10898 }
10899 if (arg1) (arg1)->CanonicalName = *arg2;
10900
10901 Py_INCREF(Py_None); resultobj = Py_None;
10902 {
10903 if (temp2)
10904 delete arg2;
10905 }
10906 return resultobj;
10907 fail:
10908 {
10909 if (temp2)
10910 delete arg2;
10911 }
10912 return NULL;
10913 }
10914
10915
10916 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
10917 PyObject *resultobj;
10918 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10919 wxString *result;
10920 PyObject * obj0 = 0 ;
10921 char *kwnames[] = {
10922 (char *) "self", NULL
10923 };
10924
10925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
10926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10927 if (SWIG_arg_fail(1)) SWIG_fail;
10928 result = (wxString *)& ((arg1)->CanonicalName);
10929
10930 {
10931 #if wxUSE_UNICODE
10932 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10933 #else
10934 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10935 #endif
10936 }
10937 return resultobj;
10938 fail:
10939 return NULL;
10940 }
10941
10942
10943 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
10944 PyObject *resultobj;
10945 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10946 wxString *arg2 = (wxString *) 0 ;
10947 bool temp2 = false ;
10948 PyObject * obj0 = 0 ;
10949 PyObject * obj1 = 0 ;
10950 char *kwnames[] = {
10951 (char *) "self",(char *) "Description", NULL
10952 };
10953
10954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
10955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10956 if (SWIG_arg_fail(1)) SWIG_fail;
10957 {
10958 arg2 = wxString_in_helper(obj1);
10959 if (arg2 == NULL) SWIG_fail;
10960 temp2 = true;
10961 }
10962 if (arg1) (arg1)->Description = *arg2;
10963
10964 Py_INCREF(Py_None); resultobj = Py_None;
10965 {
10966 if (temp2)
10967 delete arg2;
10968 }
10969 return resultobj;
10970 fail:
10971 {
10972 if (temp2)
10973 delete arg2;
10974 }
10975 return NULL;
10976 }
10977
10978
10979 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
10980 PyObject *resultobj;
10981 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10982 wxString *result;
10983 PyObject * obj0 = 0 ;
10984 char *kwnames[] = {
10985 (char *) "self", NULL
10986 };
10987
10988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
10989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10990 if (SWIG_arg_fail(1)) SWIG_fail;
10991 result = (wxString *)& ((arg1)->Description);
10992
10993 {
10994 #if wxUSE_UNICODE
10995 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10996 #else
10997 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10998 #endif
10999 }
11000 return resultobj;
11001 fail:
11002 return NULL;
11003 }
11004
11005
11006 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
11007 PyObject *obj;
11008 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11009 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
11010 Py_INCREF(obj);
11011 return Py_BuildValue((char *)"");
11012 }
11013 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11014 PyObject *resultobj;
11015 int arg1 = (int) -1 ;
11016 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11017 wxLocale *result;
11018 PyObject * obj0 = 0 ;
11019 PyObject * obj1 = 0 ;
11020 char *kwnames[] = {
11021 (char *) "language",(char *) "flags", NULL
11022 };
11023
11024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
11025 if (obj0) {
11026 {
11027 arg1 = (int)(SWIG_As_int(obj0));
11028 if (SWIG_arg_fail(1)) SWIG_fail;
11029 }
11030 }
11031 if (obj1) {
11032 {
11033 arg2 = (int)(SWIG_As_int(obj1));
11034 if (SWIG_arg_fail(2)) SWIG_fail;
11035 }
11036 }
11037 {
11038 PyThreadState* __tstate = wxPyBeginAllowThreads();
11039 result = (wxLocale *)new_wxLocale(arg1,arg2);
11040
11041 wxPyEndAllowThreads(__tstate);
11042 if (PyErr_Occurred()) SWIG_fail;
11043 }
11044 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11045 return resultobj;
11046 fail:
11047 return NULL;
11048 }
11049
11050
11051 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11052 PyObject *resultobj;
11053 wxLocale *arg1 = (wxLocale *) 0 ;
11054 PyObject * obj0 = 0 ;
11055 char *kwnames[] = {
11056 (char *) "self", NULL
11057 };
11058
11059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11061 if (SWIG_arg_fail(1)) SWIG_fail;
11062 {
11063 PyThreadState* __tstate = wxPyBeginAllowThreads();
11064 delete arg1;
11065
11066 wxPyEndAllowThreads(__tstate);
11067 if (PyErr_Occurred()) SWIG_fail;
11068 }
11069 Py_INCREF(Py_None); resultobj = Py_None;
11070 return resultobj;
11071 fail:
11072 return NULL;
11073 }
11074
11075
11076 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11077 PyObject *resultobj;
11078 wxLocale *arg1 = (wxLocale *) 0 ;
11079 wxString *arg2 = 0 ;
11080 wxString const &arg3_defvalue = wxPyEmptyString ;
11081 wxString *arg3 = (wxString *) &arg3_defvalue ;
11082 wxString const &arg4_defvalue = wxPyEmptyString ;
11083 wxString *arg4 = (wxString *) &arg4_defvalue ;
11084 bool arg5 = (bool) true ;
11085 bool arg6 = (bool) false ;
11086 bool result;
11087 bool temp2 = false ;
11088 bool temp3 = false ;
11089 bool temp4 = false ;
11090 PyObject * obj0 = 0 ;
11091 PyObject * obj1 = 0 ;
11092 PyObject * obj2 = 0 ;
11093 PyObject * obj3 = 0 ;
11094 PyObject * obj4 = 0 ;
11095 PyObject * obj5 = 0 ;
11096 char *kwnames[] = {
11097 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11098 };
11099
11100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11102 if (SWIG_arg_fail(1)) SWIG_fail;
11103 {
11104 arg2 = wxString_in_helper(obj1);
11105 if (arg2 == NULL) SWIG_fail;
11106 temp2 = true;
11107 }
11108 if (obj2) {
11109 {
11110 arg3 = wxString_in_helper(obj2);
11111 if (arg3 == NULL) SWIG_fail;
11112 temp3 = true;
11113 }
11114 }
11115 if (obj3) {
11116 {
11117 arg4 = wxString_in_helper(obj3);
11118 if (arg4 == NULL) SWIG_fail;
11119 temp4 = true;
11120 }
11121 }
11122 if (obj4) {
11123 {
11124 arg5 = (bool)(SWIG_As_bool(obj4));
11125 if (SWIG_arg_fail(5)) SWIG_fail;
11126 }
11127 }
11128 if (obj5) {
11129 {
11130 arg6 = (bool)(SWIG_As_bool(obj5));
11131 if (SWIG_arg_fail(6)) SWIG_fail;
11132 }
11133 }
11134 {
11135 PyThreadState* __tstate = wxPyBeginAllowThreads();
11136 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11137
11138 wxPyEndAllowThreads(__tstate);
11139 if (PyErr_Occurred()) SWIG_fail;
11140 }
11141 {
11142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11143 }
11144 {
11145 if (temp2)
11146 delete arg2;
11147 }
11148 {
11149 if (temp3)
11150 delete arg3;
11151 }
11152 {
11153 if (temp4)
11154 delete arg4;
11155 }
11156 return resultobj;
11157 fail:
11158 {
11159 if (temp2)
11160 delete arg2;
11161 }
11162 {
11163 if (temp3)
11164 delete arg3;
11165 }
11166 {
11167 if (temp4)
11168 delete arg4;
11169 }
11170 return NULL;
11171 }
11172
11173
11174 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11175 PyObject *resultobj;
11176 wxLocale *arg1 = (wxLocale *) 0 ;
11177 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11178 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11179 bool result;
11180 PyObject * obj0 = 0 ;
11181 PyObject * obj1 = 0 ;
11182 PyObject * obj2 = 0 ;
11183 char *kwnames[] = {
11184 (char *) "self",(char *) "language",(char *) "flags", NULL
11185 };
11186
11187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11189 if (SWIG_arg_fail(1)) SWIG_fail;
11190 if (obj1) {
11191 {
11192 arg2 = (int)(SWIG_As_int(obj1));
11193 if (SWIG_arg_fail(2)) SWIG_fail;
11194 }
11195 }
11196 if (obj2) {
11197 {
11198 arg3 = (int)(SWIG_As_int(obj2));
11199 if (SWIG_arg_fail(3)) SWIG_fail;
11200 }
11201 }
11202 {
11203 PyThreadState* __tstate = wxPyBeginAllowThreads();
11204 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11205
11206 wxPyEndAllowThreads(__tstate);
11207 if (PyErr_Occurred()) SWIG_fail;
11208 }
11209 {
11210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11211 }
11212 return resultobj;
11213 fail:
11214 return NULL;
11215 }
11216
11217
11218 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11219 PyObject *resultobj;
11220 int result;
11221 char *kwnames[] = {
11222 NULL
11223 };
11224
11225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11226 {
11227 PyThreadState* __tstate = wxPyBeginAllowThreads();
11228 result = (int)wxLocale::GetSystemLanguage();
11229
11230 wxPyEndAllowThreads(__tstate);
11231 if (PyErr_Occurred()) SWIG_fail;
11232 }
11233 {
11234 resultobj = SWIG_From_int((int)(result));
11235 }
11236 return resultobj;
11237 fail:
11238 return NULL;
11239 }
11240
11241
11242 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11243 PyObject *resultobj;
11244 wxFontEncoding result;
11245 char *kwnames[] = {
11246 NULL
11247 };
11248
11249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11250 {
11251 PyThreadState* __tstate = wxPyBeginAllowThreads();
11252 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11253
11254 wxPyEndAllowThreads(__tstate);
11255 if (PyErr_Occurred()) SWIG_fail;
11256 }
11257 resultobj = SWIG_From_int((result));
11258 return resultobj;
11259 fail:
11260 return NULL;
11261 }
11262
11263
11264 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11265 PyObject *resultobj;
11266 wxString result;
11267 char *kwnames[] = {
11268 NULL
11269 };
11270
11271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11272 {
11273 PyThreadState* __tstate = wxPyBeginAllowThreads();
11274 result = wxLocale::GetSystemEncodingName();
11275
11276 wxPyEndAllowThreads(__tstate);
11277 if (PyErr_Occurred()) SWIG_fail;
11278 }
11279 {
11280 #if wxUSE_UNICODE
11281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11282 #else
11283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11284 #endif
11285 }
11286 return resultobj;
11287 fail:
11288 return NULL;
11289 }
11290
11291
11292 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11293 PyObject *resultobj;
11294 wxLocale *arg1 = (wxLocale *) 0 ;
11295 bool result;
11296 PyObject * obj0 = 0 ;
11297 char *kwnames[] = {
11298 (char *) "self", NULL
11299 };
11300
11301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11303 if (SWIG_arg_fail(1)) SWIG_fail;
11304 {
11305 PyThreadState* __tstate = wxPyBeginAllowThreads();
11306 result = (bool)((wxLocale const *)arg1)->IsOk();
11307
11308 wxPyEndAllowThreads(__tstate);
11309 if (PyErr_Occurred()) SWIG_fail;
11310 }
11311 {
11312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11313 }
11314 return resultobj;
11315 fail:
11316 return NULL;
11317 }
11318
11319
11320 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11321 PyObject *resultobj;
11322 wxLocale *arg1 = (wxLocale *) 0 ;
11323 wxString result;
11324 PyObject * obj0 = 0 ;
11325 char *kwnames[] = {
11326 (char *) "self", NULL
11327 };
11328
11329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11331 if (SWIG_arg_fail(1)) SWIG_fail;
11332 {
11333 PyThreadState* __tstate = wxPyBeginAllowThreads();
11334 result = ((wxLocale const *)arg1)->GetLocale();
11335
11336 wxPyEndAllowThreads(__tstate);
11337 if (PyErr_Occurred()) SWIG_fail;
11338 }
11339 {
11340 #if wxUSE_UNICODE
11341 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11342 #else
11343 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11344 #endif
11345 }
11346 return resultobj;
11347 fail:
11348 return NULL;
11349 }
11350
11351
11352 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11353 PyObject *resultobj;
11354 wxLocale *arg1 = (wxLocale *) 0 ;
11355 int result;
11356 PyObject * obj0 = 0 ;
11357 char *kwnames[] = {
11358 (char *) "self", NULL
11359 };
11360
11361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
11362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11363 if (SWIG_arg_fail(1)) SWIG_fail;
11364 {
11365 PyThreadState* __tstate = wxPyBeginAllowThreads();
11366 result = (int)((wxLocale const *)arg1)->GetLanguage();
11367
11368 wxPyEndAllowThreads(__tstate);
11369 if (PyErr_Occurred()) SWIG_fail;
11370 }
11371 {
11372 resultobj = SWIG_From_int((int)(result));
11373 }
11374 return resultobj;
11375 fail:
11376 return NULL;
11377 }
11378
11379
11380 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
11381 PyObject *resultobj;
11382 wxLocale *arg1 = (wxLocale *) 0 ;
11383 wxString result;
11384 PyObject * obj0 = 0 ;
11385 char *kwnames[] = {
11386 (char *) "self", NULL
11387 };
11388
11389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
11390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11391 if (SWIG_arg_fail(1)) SWIG_fail;
11392 {
11393 PyThreadState* __tstate = wxPyBeginAllowThreads();
11394 result = ((wxLocale const *)arg1)->GetSysName();
11395
11396 wxPyEndAllowThreads(__tstate);
11397 if (PyErr_Occurred()) SWIG_fail;
11398 }
11399 {
11400 #if wxUSE_UNICODE
11401 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11402 #else
11403 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11404 #endif
11405 }
11406 return resultobj;
11407 fail:
11408 return NULL;
11409 }
11410
11411
11412 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
11413 PyObject *resultobj;
11414 wxLocale *arg1 = (wxLocale *) 0 ;
11415 wxString result;
11416 PyObject * obj0 = 0 ;
11417 char *kwnames[] = {
11418 (char *) "self", NULL
11419 };
11420
11421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
11422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11423 if (SWIG_arg_fail(1)) SWIG_fail;
11424 {
11425 PyThreadState* __tstate = wxPyBeginAllowThreads();
11426 result = ((wxLocale const *)arg1)->GetCanonicalName();
11427
11428 wxPyEndAllowThreads(__tstate);
11429 if (PyErr_Occurred()) SWIG_fail;
11430 }
11431 {
11432 #if wxUSE_UNICODE
11433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11434 #else
11435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11436 #endif
11437 }
11438 return resultobj;
11439 fail:
11440 return NULL;
11441 }
11442
11443
11444 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
11445 PyObject *resultobj;
11446 wxString *arg1 = 0 ;
11447 bool temp1 = false ;
11448 PyObject * obj0 = 0 ;
11449 char *kwnames[] = {
11450 (char *) "prefix", NULL
11451 };
11452
11453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
11454 {
11455 arg1 = wxString_in_helper(obj0);
11456 if (arg1 == NULL) SWIG_fail;
11457 temp1 = true;
11458 }
11459 {
11460 PyThreadState* __tstate = wxPyBeginAllowThreads();
11461 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
11462
11463 wxPyEndAllowThreads(__tstate);
11464 if (PyErr_Occurred()) SWIG_fail;
11465 }
11466 Py_INCREF(Py_None); resultobj = Py_None;
11467 {
11468 if (temp1)
11469 delete arg1;
11470 }
11471 return resultobj;
11472 fail:
11473 {
11474 if (temp1)
11475 delete arg1;
11476 }
11477 return NULL;
11478 }
11479
11480
11481 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
11482 PyObject *resultobj;
11483 wxLocale *arg1 = (wxLocale *) 0 ;
11484 wxString *arg2 = 0 ;
11485 bool result;
11486 bool temp2 = false ;
11487 PyObject * obj0 = 0 ;
11488 PyObject * obj1 = 0 ;
11489 char *kwnames[] = {
11490 (char *) "self",(char *) "szDomain", NULL
11491 };
11492
11493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
11494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11495 if (SWIG_arg_fail(1)) SWIG_fail;
11496 {
11497 arg2 = wxString_in_helper(obj1);
11498 if (arg2 == NULL) SWIG_fail;
11499 temp2 = true;
11500 }
11501 {
11502 PyThreadState* __tstate = wxPyBeginAllowThreads();
11503 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
11504
11505 wxPyEndAllowThreads(__tstate);
11506 if (PyErr_Occurred()) SWIG_fail;
11507 }
11508 {
11509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11510 }
11511 {
11512 if (temp2)
11513 delete arg2;
11514 }
11515 return resultobj;
11516 fail:
11517 {
11518 if (temp2)
11519 delete arg2;
11520 }
11521 return NULL;
11522 }
11523
11524
11525 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
11526 PyObject *resultobj;
11527 wxLocale *arg1 = (wxLocale *) 0 ;
11528 wxString *arg2 = 0 ;
11529 bool result;
11530 bool temp2 = false ;
11531 PyObject * obj0 = 0 ;
11532 PyObject * obj1 = 0 ;
11533 char *kwnames[] = {
11534 (char *) "self",(char *) "szDomain", NULL
11535 };
11536
11537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
11538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11539 if (SWIG_arg_fail(1)) SWIG_fail;
11540 {
11541 arg2 = wxString_in_helper(obj1);
11542 if (arg2 == NULL) SWIG_fail;
11543 temp2 = true;
11544 }
11545 {
11546 PyThreadState* __tstate = wxPyBeginAllowThreads();
11547 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
11548
11549 wxPyEndAllowThreads(__tstate);
11550 if (PyErr_Occurred()) SWIG_fail;
11551 }
11552 {
11553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11554 }
11555 {
11556 if (temp2)
11557 delete arg2;
11558 }
11559 return resultobj;
11560 fail:
11561 {
11562 if (temp2)
11563 delete arg2;
11564 }
11565 return NULL;
11566 }
11567
11568
11569 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11570 PyObject *resultobj;
11571 int arg1 ;
11572 wxLanguageInfo *result;
11573 PyObject * obj0 = 0 ;
11574 char *kwnames[] = {
11575 (char *) "lang", NULL
11576 };
11577
11578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
11579 {
11580 arg1 = (int)(SWIG_As_int(obj0));
11581 if (SWIG_arg_fail(1)) SWIG_fail;
11582 }
11583 {
11584 PyThreadState* __tstate = wxPyBeginAllowThreads();
11585 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
11586
11587 wxPyEndAllowThreads(__tstate);
11588 if (PyErr_Occurred()) SWIG_fail;
11589 }
11590 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11591 return resultobj;
11592 fail:
11593 return NULL;
11594 }
11595
11596
11597 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
11598 PyObject *resultobj;
11599 int arg1 ;
11600 wxString result;
11601 PyObject * obj0 = 0 ;
11602 char *kwnames[] = {
11603 (char *) "lang", NULL
11604 };
11605
11606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
11607 {
11608 arg1 = (int)(SWIG_As_int(obj0));
11609 if (SWIG_arg_fail(1)) SWIG_fail;
11610 }
11611 {
11612 PyThreadState* __tstate = wxPyBeginAllowThreads();
11613 result = wxLocale::GetLanguageName(arg1);
11614
11615 wxPyEndAllowThreads(__tstate);
11616 if (PyErr_Occurred()) SWIG_fail;
11617 }
11618 {
11619 #if wxUSE_UNICODE
11620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11621 #else
11622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11623 #endif
11624 }
11625 return resultobj;
11626 fail:
11627 return NULL;
11628 }
11629
11630
11631 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11632 PyObject *resultobj;
11633 wxString *arg1 = 0 ;
11634 wxLanguageInfo *result;
11635 bool temp1 = false ;
11636 PyObject * obj0 = 0 ;
11637 char *kwnames[] = {
11638 (char *) "locale", NULL
11639 };
11640
11641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
11642 {
11643 arg1 = wxString_in_helper(obj0);
11644 if (arg1 == NULL) SWIG_fail;
11645 temp1 = true;
11646 }
11647 {
11648 PyThreadState* __tstate = wxPyBeginAllowThreads();
11649 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
11650
11651 wxPyEndAllowThreads(__tstate);
11652 if (PyErr_Occurred()) SWIG_fail;
11653 }
11654 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11655 {
11656 if (temp1)
11657 delete arg1;
11658 }
11659 return resultobj;
11660 fail:
11661 {
11662 if (temp1)
11663 delete arg1;
11664 }
11665 return NULL;
11666 }
11667
11668
11669 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11670 PyObject *resultobj;
11671 wxLanguageInfo *arg1 = 0 ;
11672 PyObject * obj0 = 0 ;
11673 char *kwnames[] = {
11674 (char *) "info", NULL
11675 };
11676
11677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
11678 {
11679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11680 if (SWIG_arg_fail(1)) SWIG_fail;
11681 if (arg1 == NULL) {
11682 SWIG_null_ref("wxLanguageInfo");
11683 }
11684 if (SWIG_arg_fail(1)) SWIG_fail;
11685 }
11686 {
11687 PyThreadState* __tstate = wxPyBeginAllowThreads();
11688 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
11689
11690 wxPyEndAllowThreads(__tstate);
11691 if (PyErr_Occurred()) SWIG_fail;
11692 }
11693 Py_INCREF(Py_None); resultobj = Py_None;
11694 return resultobj;
11695 fail:
11696 return NULL;
11697 }
11698
11699
11700 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
11701 PyObject *resultobj;
11702 wxLocale *arg1 = (wxLocale *) 0 ;
11703 wxString *arg2 = 0 ;
11704 wxString const &arg3_defvalue = wxPyEmptyString ;
11705 wxString *arg3 = (wxString *) &arg3_defvalue ;
11706 wxString result;
11707 bool temp2 = false ;
11708 bool temp3 = false ;
11709 PyObject * obj0 = 0 ;
11710 PyObject * obj1 = 0 ;
11711 PyObject * obj2 = 0 ;
11712 char *kwnames[] = {
11713 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
11714 };
11715
11716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
11717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11718 if (SWIG_arg_fail(1)) SWIG_fail;
11719 {
11720 arg2 = wxString_in_helper(obj1);
11721 if (arg2 == NULL) SWIG_fail;
11722 temp2 = true;
11723 }
11724 if (obj2) {
11725 {
11726 arg3 = wxString_in_helper(obj2);
11727 if (arg3 == NULL) SWIG_fail;
11728 temp3 = true;
11729 }
11730 }
11731 {
11732 PyThreadState* __tstate = wxPyBeginAllowThreads();
11733 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
11734
11735 wxPyEndAllowThreads(__tstate);
11736 if (PyErr_Occurred()) SWIG_fail;
11737 }
11738 {
11739 #if wxUSE_UNICODE
11740 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11741 #else
11742 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11743 #endif
11744 }
11745 {
11746 if (temp2)
11747 delete arg2;
11748 }
11749 {
11750 if (temp3)
11751 delete arg3;
11752 }
11753 return resultobj;
11754 fail:
11755 {
11756 if (temp2)
11757 delete arg2;
11758 }
11759 {
11760 if (temp3)
11761 delete arg3;
11762 }
11763 return NULL;
11764 }
11765
11766
11767 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
11768 PyObject *resultobj;
11769 wxLocale *arg1 = (wxLocale *) 0 ;
11770 wxString *result;
11771 PyObject * obj0 = 0 ;
11772 char *kwnames[] = {
11773 (char *) "self", NULL
11774 };
11775
11776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
11777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11778 if (SWIG_arg_fail(1)) SWIG_fail;
11779 {
11780 PyThreadState* __tstate = wxPyBeginAllowThreads();
11781 {
11782 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
11783 result = (wxString *) &_result_ref;
11784 }
11785
11786 wxPyEndAllowThreads(__tstate);
11787 if (PyErr_Occurred()) SWIG_fail;
11788 }
11789 {
11790 #if wxUSE_UNICODE
11791 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11792 #else
11793 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11794 #endif
11795 }
11796 return resultobj;
11797 fail:
11798 return NULL;
11799 }
11800
11801
11802 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
11803 PyObject *obj;
11804 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11805 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
11806 Py_INCREF(obj);
11807 return Py_BuildValue((char *)"");
11808 }
11809 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11810 PyObject *resultobj;
11811 wxLocale *result;
11812 char *kwnames[] = {
11813 NULL
11814 };
11815
11816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
11817 {
11818 PyThreadState* __tstate = wxPyBeginAllowThreads();
11819 result = (wxLocale *)wxGetLocale();
11820
11821 wxPyEndAllowThreads(__tstate);
11822 if (PyErr_Occurred()) SWIG_fail;
11823 }
11824 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
11825 return resultobj;
11826 fail:
11827 return NULL;
11828 }
11829
11830
11831 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
11832 PyObject *resultobj;
11833 wxString *arg1 = 0 ;
11834 wxString result;
11835 bool temp1 = false ;
11836 PyObject * obj0 = 0 ;
11837
11838 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
11839 {
11840 arg1 = wxString_in_helper(obj0);
11841 if (arg1 == NULL) SWIG_fail;
11842 temp1 = true;
11843 }
11844 {
11845 PyThreadState* __tstate = wxPyBeginAllowThreads();
11846 result = wxGetTranslation((wxString const &)*arg1);
11847
11848 wxPyEndAllowThreads(__tstate);
11849 if (PyErr_Occurred()) SWIG_fail;
11850 }
11851 {
11852 #if wxUSE_UNICODE
11853 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11854 #else
11855 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11856 #endif
11857 }
11858 {
11859 if (temp1)
11860 delete arg1;
11861 }
11862 return resultobj;
11863 fail:
11864 {
11865 if (temp1)
11866 delete arg1;
11867 }
11868 return NULL;
11869 }
11870
11871
11872 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
11873 PyObject *resultobj;
11874 wxString *arg1 = 0 ;
11875 wxString *arg2 = 0 ;
11876 size_t arg3 ;
11877 wxString result;
11878 bool temp1 = false ;
11879 bool temp2 = false ;
11880 PyObject * obj0 = 0 ;
11881 PyObject * obj1 = 0 ;
11882 PyObject * obj2 = 0 ;
11883
11884 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
11885 {
11886 arg1 = wxString_in_helper(obj0);
11887 if (arg1 == NULL) SWIG_fail;
11888 temp1 = true;
11889 }
11890 {
11891 arg2 = wxString_in_helper(obj1);
11892 if (arg2 == NULL) SWIG_fail;
11893 temp2 = true;
11894 }
11895 {
11896 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
11897 if (SWIG_arg_fail(3)) SWIG_fail;
11898 }
11899 {
11900 PyThreadState* __tstate = wxPyBeginAllowThreads();
11901 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11902
11903 wxPyEndAllowThreads(__tstate);
11904 if (PyErr_Occurred()) SWIG_fail;
11905 }
11906 {
11907 #if wxUSE_UNICODE
11908 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11909 #else
11910 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11911 #endif
11912 }
11913 {
11914 if (temp1)
11915 delete arg1;
11916 }
11917 {
11918 if (temp2)
11919 delete arg2;
11920 }
11921 return resultobj;
11922 fail:
11923 {
11924 if (temp1)
11925 delete arg1;
11926 }
11927 {
11928 if (temp2)
11929 delete arg2;
11930 }
11931 return NULL;
11932 }
11933
11934
11935 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
11936 int argc;
11937 PyObject *argv[4];
11938 int ii;
11939
11940 argc = PyObject_Length(args);
11941 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
11942 argv[ii] = PyTuple_GetItem(args,ii);
11943 }
11944 if (argc == 1) {
11945 int _v;
11946 {
11947 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11948 }
11949 if (_v) {
11950 return _wrap_GetTranslation__SWIG_0(self,args);
11951 }
11952 }
11953 if (argc == 3) {
11954 int _v;
11955 {
11956 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11957 }
11958 if (_v) {
11959 {
11960 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
11961 }
11962 if (_v) {
11963 _v = SWIG_Check_unsigned_SS_long(argv[2]);
11964 if (_v) {
11965 return _wrap_GetTranslation__SWIG_1(self,args);
11966 }
11967 }
11968 }
11969 }
11970
11971 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
11972 return NULL;
11973 }
11974
11975
11976 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
11977 PyObject *resultobj;
11978 wxEncodingConverter *result;
11979 char *kwnames[] = {
11980 NULL
11981 };
11982
11983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
11984 {
11985 PyThreadState* __tstate = wxPyBeginAllowThreads();
11986 result = (wxEncodingConverter *)new wxEncodingConverter();
11987
11988 wxPyEndAllowThreads(__tstate);
11989 if (PyErr_Occurred()) SWIG_fail;
11990 }
11991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
11992 return resultobj;
11993 fail:
11994 return NULL;
11995 }
11996
11997
11998 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
11999 PyObject *resultobj;
12000 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12001 PyObject * obj0 = 0 ;
12002 char *kwnames[] = {
12003 (char *) "self", NULL
12004 };
12005
12006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
12007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12008 if (SWIG_arg_fail(1)) SWIG_fail;
12009 {
12010 PyThreadState* __tstate = wxPyBeginAllowThreads();
12011 delete arg1;
12012
12013 wxPyEndAllowThreads(__tstate);
12014 if (PyErr_Occurred()) SWIG_fail;
12015 }
12016 Py_INCREF(Py_None); resultobj = Py_None;
12017 return resultobj;
12018 fail:
12019 return NULL;
12020 }
12021
12022
12023 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
12024 PyObject *resultobj;
12025 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12026 wxFontEncoding arg2 ;
12027 wxFontEncoding arg3 ;
12028 int arg4 = (int) wxCONVERT_STRICT ;
12029 bool result;
12030 PyObject * obj0 = 0 ;
12031 PyObject * obj1 = 0 ;
12032 PyObject * obj2 = 0 ;
12033 PyObject * obj3 = 0 ;
12034 char *kwnames[] = {
12035 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
12036 };
12037
12038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12040 if (SWIG_arg_fail(1)) SWIG_fail;
12041 {
12042 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12043 if (SWIG_arg_fail(2)) SWIG_fail;
12044 }
12045 {
12046 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12047 if (SWIG_arg_fail(3)) SWIG_fail;
12048 }
12049 if (obj3) {
12050 {
12051 arg4 = (int)(SWIG_As_int(obj3));
12052 if (SWIG_arg_fail(4)) SWIG_fail;
12053 }
12054 }
12055 {
12056 PyThreadState* __tstate = wxPyBeginAllowThreads();
12057 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12058
12059 wxPyEndAllowThreads(__tstate);
12060 if (PyErr_Occurred()) SWIG_fail;
12061 }
12062 {
12063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12064 }
12065 return resultobj;
12066 fail:
12067 return NULL;
12068 }
12069
12070
12071 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12072 PyObject *resultobj;
12073 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12074 wxString *arg2 = 0 ;
12075 wxString result;
12076 bool temp2 = false ;
12077 PyObject * obj0 = 0 ;
12078 PyObject * obj1 = 0 ;
12079 char *kwnames[] = {
12080 (char *) "self",(char *) "input", NULL
12081 };
12082
12083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12085 if (SWIG_arg_fail(1)) SWIG_fail;
12086 {
12087 arg2 = wxString_in_helper(obj1);
12088 if (arg2 == NULL) SWIG_fail;
12089 temp2 = true;
12090 }
12091 {
12092 PyThreadState* __tstate = wxPyBeginAllowThreads();
12093 result = (arg1)->Convert((wxString const &)*arg2);
12094
12095 wxPyEndAllowThreads(__tstate);
12096 if (PyErr_Occurred()) SWIG_fail;
12097 }
12098 {
12099 #if wxUSE_UNICODE
12100 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12101 #else
12102 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12103 #endif
12104 }
12105 {
12106 if (temp2)
12107 delete arg2;
12108 }
12109 return resultobj;
12110 fail:
12111 {
12112 if (temp2)
12113 delete arg2;
12114 }
12115 return NULL;
12116 }
12117
12118
12119 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12120 PyObject *resultobj;
12121 wxFontEncoding arg1 ;
12122 int arg2 = (int) wxPLATFORM_CURRENT ;
12123 wxFontEncodingArray result;
12124 PyObject * obj0 = 0 ;
12125 PyObject * obj1 = 0 ;
12126 char *kwnames[] = {
12127 (char *) "enc",(char *) "platform", NULL
12128 };
12129
12130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12131 {
12132 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12133 if (SWIG_arg_fail(1)) SWIG_fail;
12134 }
12135 if (obj1) {
12136 {
12137 arg2 = (int)(SWIG_As_int(obj1));
12138 if (SWIG_arg_fail(2)) SWIG_fail;
12139 }
12140 }
12141 {
12142 PyThreadState* __tstate = wxPyBeginAllowThreads();
12143 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12144
12145 wxPyEndAllowThreads(__tstate);
12146 if (PyErr_Occurred()) SWIG_fail;
12147 }
12148 {
12149 resultobj = PyList_New(0);
12150 for (size_t i=0; i < (&result)->GetCount(); i++) {
12151 PyObject* number = PyInt_FromLong((&result)->Item(i));
12152 PyList_Append(resultobj, number);
12153 Py_DECREF(number);
12154 }
12155 }
12156 return resultobj;
12157 fail:
12158 return NULL;
12159 }
12160
12161
12162 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12163 PyObject *resultobj;
12164 wxFontEncoding arg1 ;
12165 wxFontEncodingArray result;
12166 PyObject * obj0 = 0 ;
12167 char *kwnames[] = {
12168 (char *) "enc", NULL
12169 };
12170
12171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12172 {
12173 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12174 if (SWIG_arg_fail(1)) SWIG_fail;
12175 }
12176 {
12177 PyThreadState* __tstate = wxPyBeginAllowThreads();
12178 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12179
12180 wxPyEndAllowThreads(__tstate);
12181 if (PyErr_Occurred()) SWIG_fail;
12182 }
12183 {
12184 resultobj = PyList_New(0);
12185 for (size_t i=0; i < (&result)->GetCount(); i++) {
12186 PyObject* number = PyInt_FromLong((&result)->Item(i));
12187 PyList_Append(resultobj, number);
12188 Py_DECREF(number);
12189 }
12190 }
12191 return resultobj;
12192 fail:
12193 return NULL;
12194 }
12195
12196
12197 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12198 PyObject *resultobj;
12199 wxFontEncoding arg1 ;
12200 wxFontEncoding arg2 ;
12201 bool result;
12202 PyObject * obj0 = 0 ;
12203 PyObject * obj1 = 0 ;
12204 char *kwnames[] = {
12205 (char *) "encIn",(char *) "encOut", NULL
12206 };
12207
12208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12209 {
12210 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12211 if (SWIG_arg_fail(1)) SWIG_fail;
12212 }
12213 {
12214 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12215 if (SWIG_arg_fail(2)) SWIG_fail;
12216 }
12217 {
12218 PyThreadState* __tstate = wxPyBeginAllowThreads();
12219 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12220
12221 wxPyEndAllowThreads(__tstate);
12222 if (PyErr_Occurred()) SWIG_fail;
12223 }
12224 {
12225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12226 }
12227 return resultobj;
12228 fail:
12229 return NULL;
12230 }
12231
12232
12233 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12234 PyObject *obj;
12235 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12236 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12237 Py_INCREF(obj);
12238 return Py_BuildValue((char *)"");
12239 }
12240 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12241 PyObject *resultobj;
12242 wxDC *arg1 = (wxDC *) 0 ;
12243 PyObject * obj0 = 0 ;
12244 char *kwnames[] = {
12245 (char *) "self", NULL
12246 };
12247
12248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12250 if (SWIG_arg_fail(1)) SWIG_fail;
12251 {
12252 PyThreadState* __tstate = wxPyBeginAllowThreads();
12253 delete arg1;
12254
12255 wxPyEndAllowThreads(__tstate);
12256 if (PyErr_Occurred()) SWIG_fail;
12257 }
12258 Py_INCREF(Py_None); resultobj = Py_None;
12259 return resultobj;
12260 fail:
12261 return NULL;
12262 }
12263
12264
12265 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12266 PyObject *resultobj;
12267 wxDC *arg1 = (wxDC *) 0 ;
12268 PyObject * obj0 = 0 ;
12269 char *kwnames[] = {
12270 (char *) "self", NULL
12271 };
12272
12273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12275 if (SWIG_arg_fail(1)) SWIG_fail;
12276 {
12277 PyThreadState* __tstate = wxPyBeginAllowThreads();
12278 (arg1)->BeginDrawing();
12279
12280 wxPyEndAllowThreads(__tstate);
12281 if (PyErr_Occurred()) SWIG_fail;
12282 }
12283 Py_INCREF(Py_None); resultobj = Py_None;
12284 return resultobj;
12285 fail:
12286 return NULL;
12287 }
12288
12289
12290 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12291 PyObject *resultobj;
12292 wxDC *arg1 = (wxDC *) 0 ;
12293 PyObject * obj0 = 0 ;
12294 char *kwnames[] = {
12295 (char *) "self", NULL
12296 };
12297
12298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12300 if (SWIG_arg_fail(1)) SWIG_fail;
12301 {
12302 PyThreadState* __tstate = wxPyBeginAllowThreads();
12303 (arg1)->EndDrawing();
12304
12305 wxPyEndAllowThreads(__tstate);
12306 if (PyErr_Occurred()) SWIG_fail;
12307 }
12308 Py_INCREF(Py_None); resultobj = Py_None;
12309 return resultobj;
12310 fail:
12311 return NULL;
12312 }
12313
12314
12315 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12316 PyObject *resultobj;
12317 wxDC *arg1 = (wxDC *) 0 ;
12318 int arg2 ;
12319 int arg3 ;
12320 wxColour *arg4 = 0 ;
12321 int arg5 = (int) wxFLOOD_SURFACE ;
12322 bool result;
12323 wxColour temp4 ;
12324 PyObject * obj0 = 0 ;
12325 PyObject * obj1 = 0 ;
12326 PyObject * obj2 = 0 ;
12327 PyObject * obj3 = 0 ;
12328 PyObject * obj4 = 0 ;
12329 char *kwnames[] = {
12330 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12331 };
12332
12333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12335 if (SWIG_arg_fail(1)) SWIG_fail;
12336 {
12337 arg2 = (int)(SWIG_As_int(obj1));
12338 if (SWIG_arg_fail(2)) SWIG_fail;
12339 }
12340 {
12341 arg3 = (int)(SWIG_As_int(obj2));
12342 if (SWIG_arg_fail(3)) SWIG_fail;
12343 }
12344 {
12345 arg4 = &temp4;
12346 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12347 }
12348 if (obj4) {
12349 {
12350 arg5 = (int)(SWIG_As_int(obj4));
12351 if (SWIG_arg_fail(5)) SWIG_fail;
12352 }
12353 }
12354 {
12355 PyThreadState* __tstate = wxPyBeginAllowThreads();
12356 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
12357
12358 wxPyEndAllowThreads(__tstate);
12359 if (PyErr_Occurred()) SWIG_fail;
12360 }
12361 {
12362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12363 }
12364 return resultobj;
12365 fail:
12366 return NULL;
12367 }
12368
12369
12370 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12371 PyObject *resultobj;
12372 wxDC *arg1 = (wxDC *) 0 ;
12373 wxPoint *arg2 = 0 ;
12374 wxColour *arg3 = 0 ;
12375 int arg4 = (int) wxFLOOD_SURFACE ;
12376 bool result;
12377 wxPoint temp2 ;
12378 wxColour temp3 ;
12379 PyObject * obj0 = 0 ;
12380 PyObject * obj1 = 0 ;
12381 PyObject * obj2 = 0 ;
12382 PyObject * obj3 = 0 ;
12383 char *kwnames[] = {
12384 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
12385 };
12386
12387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg2 = &temp2;
12392 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12393 }
12394 {
12395 arg3 = &temp3;
12396 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
12397 }
12398 if (obj3) {
12399 {
12400 arg4 = (int)(SWIG_As_int(obj3));
12401 if (SWIG_arg_fail(4)) SWIG_fail;
12402 }
12403 }
12404 {
12405 PyThreadState* __tstate = wxPyBeginAllowThreads();
12406 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
12407
12408 wxPyEndAllowThreads(__tstate);
12409 if (PyErr_Occurred()) SWIG_fail;
12410 }
12411 {
12412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12413 }
12414 return resultobj;
12415 fail:
12416 return NULL;
12417 }
12418
12419
12420 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
12421 PyObject *resultobj;
12422 wxDC *arg1 = (wxDC *) 0 ;
12423 int arg2 ;
12424 int arg3 ;
12425 wxColour result;
12426 PyObject * obj0 = 0 ;
12427 PyObject * obj1 = 0 ;
12428 PyObject * obj2 = 0 ;
12429 char *kwnames[] = {
12430 (char *) "self",(char *) "x",(char *) "y", NULL
12431 };
12432
12433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
12434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12435 if (SWIG_arg_fail(1)) SWIG_fail;
12436 {
12437 arg2 = (int)(SWIG_As_int(obj1));
12438 if (SWIG_arg_fail(2)) SWIG_fail;
12439 }
12440 {
12441 arg3 = (int)(SWIG_As_int(obj2));
12442 if (SWIG_arg_fail(3)) SWIG_fail;
12443 }
12444 {
12445 PyThreadState* __tstate = wxPyBeginAllowThreads();
12446 result = wxDC_GetPixel(arg1,arg2,arg3);
12447
12448 wxPyEndAllowThreads(__tstate);
12449 if (PyErr_Occurred()) SWIG_fail;
12450 }
12451 {
12452 wxColour * resultptr;
12453 resultptr = new wxColour((wxColour &)(result));
12454 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12455 }
12456 return resultobj;
12457 fail:
12458 return NULL;
12459 }
12460
12461
12462 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12463 PyObject *resultobj;
12464 wxDC *arg1 = (wxDC *) 0 ;
12465 wxPoint *arg2 = 0 ;
12466 wxColour result;
12467 wxPoint temp2 ;
12468 PyObject * obj0 = 0 ;
12469 PyObject * obj1 = 0 ;
12470 char *kwnames[] = {
12471 (char *) "self",(char *) "pt", NULL
12472 };
12473
12474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
12475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12476 if (SWIG_arg_fail(1)) SWIG_fail;
12477 {
12478 arg2 = &temp2;
12479 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12480 }
12481 {
12482 PyThreadState* __tstate = wxPyBeginAllowThreads();
12483 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
12484
12485 wxPyEndAllowThreads(__tstate);
12486 if (PyErr_Occurred()) SWIG_fail;
12487 }
12488 {
12489 wxColour * resultptr;
12490 resultptr = new wxColour((wxColour &)(result));
12491 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12492 }
12493 return resultobj;
12494 fail:
12495 return NULL;
12496 }
12497
12498
12499 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
12500 PyObject *resultobj;
12501 wxDC *arg1 = (wxDC *) 0 ;
12502 int arg2 ;
12503 int arg3 ;
12504 int arg4 ;
12505 int arg5 ;
12506 PyObject * obj0 = 0 ;
12507 PyObject * obj1 = 0 ;
12508 PyObject * obj2 = 0 ;
12509 PyObject * obj3 = 0 ;
12510 PyObject * obj4 = 0 ;
12511 char *kwnames[] = {
12512 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
12513 };
12514
12515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12517 if (SWIG_arg_fail(1)) SWIG_fail;
12518 {
12519 arg2 = (int)(SWIG_As_int(obj1));
12520 if (SWIG_arg_fail(2)) SWIG_fail;
12521 }
12522 {
12523 arg3 = (int)(SWIG_As_int(obj2));
12524 if (SWIG_arg_fail(3)) SWIG_fail;
12525 }
12526 {
12527 arg4 = (int)(SWIG_As_int(obj3));
12528 if (SWIG_arg_fail(4)) SWIG_fail;
12529 }
12530 {
12531 arg5 = (int)(SWIG_As_int(obj4));
12532 if (SWIG_arg_fail(5)) SWIG_fail;
12533 }
12534 {
12535 PyThreadState* __tstate = wxPyBeginAllowThreads();
12536 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
12537
12538 wxPyEndAllowThreads(__tstate);
12539 if (PyErr_Occurred()) SWIG_fail;
12540 }
12541 Py_INCREF(Py_None); resultobj = Py_None;
12542 return resultobj;
12543 fail:
12544 return NULL;
12545 }
12546
12547
12548 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
12549 PyObject *resultobj;
12550 wxDC *arg1 = (wxDC *) 0 ;
12551 wxPoint *arg2 = 0 ;
12552 wxPoint *arg3 = 0 ;
12553 wxPoint temp2 ;
12554 wxPoint temp3 ;
12555 PyObject * obj0 = 0 ;
12556 PyObject * obj1 = 0 ;
12557 PyObject * obj2 = 0 ;
12558 char *kwnames[] = {
12559 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
12560 };
12561
12562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12564 if (SWIG_arg_fail(1)) SWIG_fail;
12565 {
12566 arg2 = &temp2;
12567 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12568 }
12569 {
12570 arg3 = &temp3;
12571 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12572 }
12573 {
12574 PyThreadState* __tstate = wxPyBeginAllowThreads();
12575 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
12576
12577 wxPyEndAllowThreads(__tstate);
12578 if (PyErr_Occurred()) SWIG_fail;
12579 }
12580 Py_INCREF(Py_None); resultobj = Py_None;
12581 return resultobj;
12582 fail:
12583 return NULL;
12584 }
12585
12586
12587 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
12588 PyObject *resultobj;
12589 wxDC *arg1 = (wxDC *) 0 ;
12590 int arg2 ;
12591 int arg3 ;
12592 PyObject * obj0 = 0 ;
12593 PyObject * obj1 = 0 ;
12594 PyObject * obj2 = 0 ;
12595 char *kwnames[] = {
12596 (char *) "self",(char *) "x",(char *) "y", NULL
12597 };
12598
12599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
12600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12601 if (SWIG_arg_fail(1)) SWIG_fail;
12602 {
12603 arg2 = (int)(SWIG_As_int(obj1));
12604 if (SWIG_arg_fail(2)) SWIG_fail;
12605 }
12606 {
12607 arg3 = (int)(SWIG_As_int(obj2));
12608 if (SWIG_arg_fail(3)) SWIG_fail;
12609 }
12610 {
12611 PyThreadState* __tstate = wxPyBeginAllowThreads();
12612 (arg1)->CrossHair(arg2,arg3);
12613
12614 wxPyEndAllowThreads(__tstate);
12615 if (PyErr_Occurred()) SWIG_fail;
12616 }
12617 Py_INCREF(Py_None); resultobj = Py_None;
12618 return resultobj;
12619 fail:
12620 return NULL;
12621 }
12622
12623
12624 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12625 PyObject *resultobj;
12626 wxDC *arg1 = (wxDC *) 0 ;
12627 wxPoint *arg2 = 0 ;
12628 wxPoint temp2 ;
12629 PyObject * obj0 = 0 ;
12630 PyObject * obj1 = 0 ;
12631 char *kwnames[] = {
12632 (char *) "self",(char *) "pt", NULL
12633 };
12634
12635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
12636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12637 if (SWIG_arg_fail(1)) SWIG_fail;
12638 {
12639 arg2 = &temp2;
12640 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12641 }
12642 {
12643 PyThreadState* __tstate = wxPyBeginAllowThreads();
12644 (arg1)->CrossHair((wxPoint const &)*arg2);
12645
12646 wxPyEndAllowThreads(__tstate);
12647 if (PyErr_Occurred()) SWIG_fail;
12648 }
12649 Py_INCREF(Py_None); resultobj = Py_None;
12650 return resultobj;
12651 fail:
12652 return NULL;
12653 }
12654
12655
12656 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
12657 PyObject *resultobj;
12658 wxDC *arg1 = (wxDC *) 0 ;
12659 int arg2 ;
12660 int arg3 ;
12661 int arg4 ;
12662 int arg5 ;
12663 int arg6 ;
12664 int arg7 ;
12665 PyObject * obj0 = 0 ;
12666 PyObject * obj1 = 0 ;
12667 PyObject * obj2 = 0 ;
12668 PyObject * obj3 = 0 ;
12669 PyObject * obj4 = 0 ;
12670 PyObject * obj5 = 0 ;
12671 PyObject * obj6 = 0 ;
12672 char *kwnames[] = {
12673 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
12674 };
12675
12676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12678 if (SWIG_arg_fail(1)) SWIG_fail;
12679 {
12680 arg2 = (int)(SWIG_As_int(obj1));
12681 if (SWIG_arg_fail(2)) SWIG_fail;
12682 }
12683 {
12684 arg3 = (int)(SWIG_As_int(obj2));
12685 if (SWIG_arg_fail(3)) SWIG_fail;
12686 }
12687 {
12688 arg4 = (int)(SWIG_As_int(obj3));
12689 if (SWIG_arg_fail(4)) SWIG_fail;
12690 }
12691 {
12692 arg5 = (int)(SWIG_As_int(obj4));
12693 if (SWIG_arg_fail(5)) SWIG_fail;
12694 }
12695 {
12696 arg6 = (int)(SWIG_As_int(obj5));
12697 if (SWIG_arg_fail(6)) SWIG_fail;
12698 }
12699 {
12700 arg7 = (int)(SWIG_As_int(obj6));
12701 if (SWIG_arg_fail(7)) SWIG_fail;
12702 }
12703 {
12704 PyThreadState* __tstate = wxPyBeginAllowThreads();
12705 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
12706
12707 wxPyEndAllowThreads(__tstate);
12708 if (PyErr_Occurred()) SWIG_fail;
12709 }
12710 Py_INCREF(Py_None); resultobj = Py_None;
12711 return resultobj;
12712 fail:
12713 return NULL;
12714 }
12715
12716
12717 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12718 PyObject *resultobj;
12719 wxDC *arg1 = (wxDC *) 0 ;
12720 wxPoint *arg2 = 0 ;
12721 wxPoint *arg3 = 0 ;
12722 wxPoint *arg4 = 0 ;
12723 wxPoint temp2 ;
12724 wxPoint temp3 ;
12725 wxPoint temp4 ;
12726 PyObject * obj0 = 0 ;
12727 PyObject * obj1 = 0 ;
12728 PyObject * obj2 = 0 ;
12729 PyObject * obj3 = 0 ;
12730 char *kwnames[] = {
12731 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
12732 };
12733
12734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12736 if (SWIG_arg_fail(1)) SWIG_fail;
12737 {
12738 arg2 = &temp2;
12739 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12740 }
12741 {
12742 arg3 = &temp3;
12743 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12744 }
12745 {
12746 arg4 = &temp4;
12747 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12748 }
12749 {
12750 PyThreadState* __tstate = wxPyBeginAllowThreads();
12751 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
12752
12753 wxPyEndAllowThreads(__tstate);
12754 if (PyErr_Occurred()) SWIG_fail;
12755 }
12756 Py_INCREF(Py_None); resultobj = Py_None;
12757 return resultobj;
12758 fail:
12759 return NULL;
12760 }
12761
12762
12763 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
12764 PyObject *resultobj;
12765 wxDC *arg1 = (wxDC *) 0 ;
12766 int arg2 ;
12767 int arg3 ;
12768 int arg4 ;
12769 int arg5 ;
12770 PyObject * obj0 = 0 ;
12771 PyObject * obj1 = 0 ;
12772 PyObject * obj2 = 0 ;
12773 PyObject * obj3 = 0 ;
12774 PyObject * obj4 = 0 ;
12775 char *kwnames[] = {
12776 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
12777 };
12778
12779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12781 if (SWIG_arg_fail(1)) SWIG_fail;
12782 {
12783 arg2 = (int)(SWIG_As_int(obj1));
12784 if (SWIG_arg_fail(2)) SWIG_fail;
12785 }
12786 {
12787 arg3 = (int)(SWIG_As_int(obj2));
12788 if (SWIG_arg_fail(3)) SWIG_fail;
12789 }
12790 {
12791 arg4 = (int)(SWIG_As_int(obj3));
12792 if (SWIG_arg_fail(4)) SWIG_fail;
12793 }
12794 {
12795 arg5 = (int)(SWIG_As_int(obj4));
12796 if (SWIG_arg_fail(5)) SWIG_fail;
12797 }
12798 {
12799 PyThreadState* __tstate = wxPyBeginAllowThreads();
12800 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
12801
12802 wxPyEndAllowThreads(__tstate);
12803 if (PyErr_Occurred()) SWIG_fail;
12804 }
12805 Py_INCREF(Py_None); resultobj = Py_None;
12806 return resultobj;
12807 fail:
12808 return NULL;
12809 }
12810
12811
12812 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
12813 PyObject *resultobj;
12814 wxDC *arg1 = (wxDC *) 0 ;
12815 wxRect *arg2 = 0 ;
12816 wxRect temp2 ;
12817 PyObject * obj0 = 0 ;
12818 PyObject * obj1 = 0 ;
12819 char *kwnames[] = {
12820 (char *) "self",(char *) "rect", NULL
12821 };
12822
12823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) 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 ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12829 }
12830 {
12831 PyThreadState* __tstate = wxPyBeginAllowThreads();
12832 (arg1)->DrawCheckMark((wxRect const &)*arg2);
12833
12834 wxPyEndAllowThreads(__tstate);
12835 if (PyErr_Occurred()) SWIG_fail;
12836 }
12837 Py_INCREF(Py_None); resultobj = Py_None;
12838 return resultobj;
12839 fail:
12840 return NULL;
12841 }
12842
12843
12844 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
12845 PyObject *resultobj;
12846 wxDC *arg1 = (wxDC *) 0 ;
12847 int arg2 ;
12848 int arg3 ;
12849 int arg4 ;
12850 int arg5 ;
12851 double arg6 ;
12852 double arg7 ;
12853 PyObject * obj0 = 0 ;
12854 PyObject * obj1 = 0 ;
12855 PyObject * obj2 = 0 ;
12856 PyObject * obj3 = 0 ;
12857 PyObject * obj4 = 0 ;
12858 PyObject * obj5 = 0 ;
12859 PyObject * obj6 = 0 ;
12860 char *kwnames[] = {
12861 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
12862 };
12863
12864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12866 if (SWIG_arg_fail(1)) SWIG_fail;
12867 {
12868 arg2 = (int)(SWIG_As_int(obj1));
12869 if (SWIG_arg_fail(2)) SWIG_fail;
12870 }
12871 {
12872 arg3 = (int)(SWIG_As_int(obj2));
12873 if (SWIG_arg_fail(3)) SWIG_fail;
12874 }
12875 {
12876 arg4 = (int)(SWIG_As_int(obj3));
12877 if (SWIG_arg_fail(4)) SWIG_fail;
12878 }
12879 {
12880 arg5 = (int)(SWIG_As_int(obj4));
12881 if (SWIG_arg_fail(5)) SWIG_fail;
12882 }
12883 {
12884 arg6 = (double)(SWIG_As_double(obj5));
12885 if (SWIG_arg_fail(6)) SWIG_fail;
12886 }
12887 {
12888 arg7 = (double)(SWIG_As_double(obj6));
12889 if (SWIG_arg_fail(7)) SWIG_fail;
12890 }
12891 {
12892 PyThreadState* __tstate = wxPyBeginAllowThreads();
12893 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
12894
12895 wxPyEndAllowThreads(__tstate);
12896 if (PyErr_Occurred()) SWIG_fail;
12897 }
12898 Py_INCREF(Py_None); resultobj = Py_None;
12899 return resultobj;
12900 fail:
12901 return NULL;
12902 }
12903
12904
12905 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
12906 PyObject *resultobj;
12907 wxDC *arg1 = (wxDC *) 0 ;
12908 wxPoint *arg2 = 0 ;
12909 wxSize *arg3 = 0 ;
12910 double arg4 ;
12911 double arg5 ;
12912 wxPoint temp2 ;
12913 wxSize temp3 ;
12914 PyObject * obj0 = 0 ;
12915 PyObject * obj1 = 0 ;
12916 PyObject * obj2 = 0 ;
12917 PyObject * obj3 = 0 ;
12918 PyObject * obj4 = 0 ;
12919 char *kwnames[] = {
12920 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
12921 };
12922
12923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12925 if (SWIG_arg_fail(1)) SWIG_fail;
12926 {
12927 arg2 = &temp2;
12928 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12929 }
12930 {
12931 arg3 = &temp3;
12932 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
12933 }
12934 {
12935 arg4 = (double)(SWIG_As_double(obj3));
12936 if (SWIG_arg_fail(4)) SWIG_fail;
12937 }
12938 {
12939 arg5 = (double)(SWIG_As_double(obj4));
12940 if (SWIG_arg_fail(5)) SWIG_fail;
12941 }
12942 {
12943 PyThreadState* __tstate = wxPyBeginAllowThreads();
12944 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
12945
12946 wxPyEndAllowThreads(__tstate);
12947 if (PyErr_Occurred()) SWIG_fail;
12948 }
12949 Py_INCREF(Py_None); resultobj = Py_None;
12950 return resultobj;
12951 fail:
12952 return NULL;
12953 }
12954
12955
12956 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12957 PyObject *resultobj;
12958 wxDC *arg1 = (wxDC *) 0 ;
12959 int arg2 ;
12960 int arg3 ;
12961 PyObject * obj0 = 0 ;
12962 PyObject * obj1 = 0 ;
12963 PyObject * obj2 = 0 ;
12964 char *kwnames[] = {
12965 (char *) "self",(char *) "x",(char *) "y", NULL
12966 };
12967
12968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12970 if (SWIG_arg_fail(1)) SWIG_fail;
12971 {
12972 arg2 = (int)(SWIG_As_int(obj1));
12973 if (SWIG_arg_fail(2)) SWIG_fail;
12974 }
12975 {
12976 arg3 = (int)(SWIG_As_int(obj2));
12977 if (SWIG_arg_fail(3)) SWIG_fail;
12978 }
12979 {
12980 PyThreadState* __tstate = wxPyBeginAllowThreads();
12981 (arg1)->DrawPoint(arg2,arg3);
12982
12983 wxPyEndAllowThreads(__tstate);
12984 if (PyErr_Occurred()) SWIG_fail;
12985 }
12986 Py_INCREF(Py_None); resultobj = Py_None;
12987 return resultobj;
12988 fail:
12989 return NULL;
12990 }
12991
12992
12993 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12994 PyObject *resultobj;
12995 wxDC *arg1 = (wxDC *) 0 ;
12996 wxPoint *arg2 = 0 ;
12997 wxPoint temp2 ;
12998 PyObject * obj0 = 0 ;
12999 PyObject * obj1 = 0 ;
13000 char *kwnames[] = {
13001 (char *) "self",(char *) "pt", NULL
13002 };
13003
13004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
13005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13006 if (SWIG_arg_fail(1)) SWIG_fail;
13007 {
13008 arg2 = &temp2;
13009 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13010 }
13011 {
13012 PyThreadState* __tstate = wxPyBeginAllowThreads();
13013 (arg1)->DrawPoint((wxPoint const &)*arg2);
13014
13015 wxPyEndAllowThreads(__tstate);
13016 if (PyErr_Occurred()) SWIG_fail;
13017 }
13018 Py_INCREF(Py_None); resultobj = Py_None;
13019 return resultobj;
13020 fail:
13021 return NULL;
13022 }
13023
13024
13025 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13026 PyObject *resultobj;
13027 wxDC *arg1 = (wxDC *) 0 ;
13028 int arg2 ;
13029 int arg3 ;
13030 int arg4 ;
13031 int arg5 ;
13032 PyObject * obj0 = 0 ;
13033 PyObject * obj1 = 0 ;
13034 PyObject * obj2 = 0 ;
13035 PyObject * obj3 = 0 ;
13036 PyObject * obj4 = 0 ;
13037 char *kwnames[] = {
13038 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13039 };
13040
13041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13043 if (SWIG_arg_fail(1)) SWIG_fail;
13044 {
13045 arg2 = (int)(SWIG_As_int(obj1));
13046 if (SWIG_arg_fail(2)) SWIG_fail;
13047 }
13048 {
13049 arg3 = (int)(SWIG_As_int(obj2));
13050 if (SWIG_arg_fail(3)) SWIG_fail;
13051 }
13052 {
13053 arg4 = (int)(SWIG_As_int(obj3));
13054 if (SWIG_arg_fail(4)) SWIG_fail;
13055 }
13056 {
13057 arg5 = (int)(SWIG_As_int(obj4));
13058 if (SWIG_arg_fail(5)) SWIG_fail;
13059 }
13060 {
13061 PyThreadState* __tstate = wxPyBeginAllowThreads();
13062 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13063
13064 wxPyEndAllowThreads(__tstate);
13065 if (PyErr_Occurred()) SWIG_fail;
13066 }
13067 Py_INCREF(Py_None); resultobj = Py_None;
13068 return resultobj;
13069 fail:
13070 return NULL;
13071 }
13072
13073
13074 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13075 PyObject *resultobj;
13076 wxDC *arg1 = (wxDC *) 0 ;
13077 wxRect *arg2 = 0 ;
13078 wxRect temp2 ;
13079 PyObject * obj0 = 0 ;
13080 PyObject * obj1 = 0 ;
13081 char *kwnames[] = {
13082 (char *) "self",(char *) "rect", NULL
13083 };
13084
13085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13087 if (SWIG_arg_fail(1)) SWIG_fail;
13088 {
13089 arg2 = &temp2;
13090 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13091 }
13092 {
13093 PyThreadState* __tstate = wxPyBeginAllowThreads();
13094 (arg1)->DrawRectangle((wxRect const &)*arg2);
13095
13096 wxPyEndAllowThreads(__tstate);
13097 if (PyErr_Occurred()) SWIG_fail;
13098 }
13099 Py_INCREF(Py_None); resultobj = Py_None;
13100 return resultobj;
13101 fail:
13102 return NULL;
13103 }
13104
13105
13106 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13107 PyObject *resultobj;
13108 wxDC *arg1 = (wxDC *) 0 ;
13109 wxPoint *arg2 = 0 ;
13110 wxSize *arg3 = 0 ;
13111 wxPoint temp2 ;
13112 wxSize temp3 ;
13113 PyObject * obj0 = 0 ;
13114 PyObject * obj1 = 0 ;
13115 PyObject * obj2 = 0 ;
13116 char *kwnames[] = {
13117 (char *) "self",(char *) "pt",(char *) "sz", NULL
13118 };
13119
13120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13122 if (SWIG_arg_fail(1)) SWIG_fail;
13123 {
13124 arg2 = &temp2;
13125 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13126 }
13127 {
13128 arg3 = &temp3;
13129 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13130 }
13131 {
13132 PyThreadState* __tstate = wxPyBeginAllowThreads();
13133 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13134
13135 wxPyEndAllowThreads(__tstate);
13136 if (PyErr_Occurred()) SWIG_fail;
13137 }
13138 Py_INCREF(Py_None); resultobj = Py_None;
13139 return resultobj;
13140 fail:
13141 return NULL;
13142 }
13143
13144
13145 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13146 PyObject *resultobj;
13147 wxDC *arg1 = (wxDC *) 0 ;
13148 int arg2 ;
13149 int arg3 ;
13150 int arg4 ;
13151 int arg5 ;
13152 double arg6 ;
13153 PyObject * obj0 = 0 ;
13154 PyObject * obj1 = 0 ;
13155 PyObject * obj2 = 0 ;
13156 PyObject * obj3 = 0 ;
13157 PyObject * obj4 = 0 ;
13158 PyObject * obj5 = 0 ;
13159 char *kwnames[] = {
13160 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13161 };
13162
13163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13165 if (SWIG_arg_fail(1)) SWIG_fail;
13166 {
13167 arg2 = (int)(SWIG_As_int(obj1));
13168 if (SWIG_arg_fail(2)) SWIG_fail;
13169 }
13170 {
13171 arg3 = (int)(SWIG_As_int(obj2));
13172 if (SWIG_arg_fail(3)) SWIG_fail;
13173 }
13174 {
13175 arg4 = (int)(SWIG_As_int(obj3));
13176 if (SWIG_arg_fail(4)) SWIG_fail;
13177 }
13178 {
13179 arg5 = (int)(SWIG_As_int(obj4));
13180 if (SWIG_arg_fail(5)) SWIG_fail;
13181 }
13182 {
13183 arg6 = (double)(SWIG_As_double(obj5));
13184 if (SWIG_arg_fail(6)) SWIG_fail;
13185 }
13186 {
13187 PyThreadState* __tstate = wxPyBeginAllowThreads();
13188 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13189
13190 wxPyEndAllowThreads(__tstate);
13191 if (PyErr_Occurred()) SWIG_fail;
13192 }
13193 Py_INCREF(Py_None); resultobj = Py_None;
13194 return resultobj;
13195 fail:
13196 return NULL;
13197 }
13198
13199
13200 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13201 PyObject *resultobj;
13202 wxDC *arg1 = (wxDC *) 0 ;
13203 wxRect *arg2 = 0 ;
13204 double arg3 ;
13205 wxRect temp2 ;
13206 PyObject * obj0 = 0 ;
13207 PyObject * obj1 = 0 ;
13208 PyObject * obj2 = 0 ;
13209 char *kwnames[] = {
13210 (char *) "self",(char *) "r",(char *) "radius", NULL
13211 };
13212
13213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13215 if (SWIG_arg_fail(1)) SWIG_fail;
13216 {
13217 arg2 = &temp2;
13218 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13219 }
13220 {
13221 arg3 = (double)(SWIG_As_double(obj2));
13222 if (SWIG_arg_fail(3)) SWIG_fail;
13223 }
13224 {
13225 PyThreadState* __tstate = wxPyBeginAllowThreads();
13226 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13227
13228 wxPyEndAllowThreads(__tstate);
13229 if (PyErr_Occurred()) SWIG_fail;
13230 }
13231 Py_INCREF(Py_None); resultobj = Py_None;
13232 return resultobj;
13233 fail:
13234 return NULL;
13235 }
13236
13237
13238 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13239 PyObject *resultobj;
13240 wxDC *arg1 = (wxDC *) 0 ;
13241 wxPoint *arg2 = 0 ;
13242 wxSize *arg3 = 0 ;
13243 double arg4 ;
13244 wxPoint temp2 ;
13245 wxSize temp3 ;
13246 PyObject * obj0 = 0 ;
13247 PyObject * obj1 = 0 ;
13248 PyObject * obj2 = 0 ;
13249 PyObject * obj3 = 0 ;
13250 char *kwnames[] = {
13251 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13252 };
13253
13254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13256 if (SWIG_arg_fail(1)) SWIG_fail;
13257 {
13258 arg2 = &temp2;
13259 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13260 }
13261 {
13262 arg3 = &temp3;
13263 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13264 }
13265 {
13266 arg4 = (double)(SWIG_As_double(obj3));
13267 if (SWIG_arg_fail(4)) SWIG_fail;
13268 }
13269 {
13270 PyThreadState* __tstate = wxPyBeginAllowThreads();
13271 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13272
13273 wxPyEndAllowThreads(__tstate);
13274 if (PyErr_Occurred()) SWIG_fail;
13275 }
13276 Py_INCREF(Py_None); resultobj = Py_None;
13277 return resultobj;
13278 fail:
13279 return NULL;
13280 }
13281
13282
13283 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13284 PyObject *resultobj;
13285 wxDC *arg1 = (wxDC *) 0 ;
13286 int arg2 ;
13287 int arg3 ;
13288 int arg4 ;
13289 PyObject * obj0 = 0 ;
13290 PyObject * obj1 = 0 ;
13291 PyObject * obj2 = 0 ;
13292 PyObject * obj3 = 0 ;
13293 char *kwnames[] = {
13294 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13295 };
13296
13297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13299 if (SWIG_arg_fail(1)) SWIG_fail;
13300 {
13301 arg2 = (int)(SWIG_As_int(obj1));
13302 if (SWIG_arg_fail(2)) SWIG_fail;
13303 }
13304 {
13305 arg3 = (int)(SWIG_As_int(obj2));
13306 if (SWIG_arg_fail(3)) SWIG_fail;
13307 }
13308 {
13309 arg4 = (int)(SWIG_As_int(obj3));
13310 if (SWIG_arg_fail(4)) SWIG_fail;
13311 }
13312 {
13313 PyThreadState* __tstate = wxPyBeginAllowThreads();
13314 (arg1)->DrawCircle(arg2,arg3,arg4);
13315
13316 wxPyEndAllowThreads(__tstate);
13317 if (PyErr_Occurred()) SWIG_fail;
13318 }
13319 Py_INCREF(Py_None); resultobj = Py_None;
13320 return resultobj;
13321 fail:
13322 return NULL;
13323 }
13324
13325
13326 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13327 PyObject *resultobj;
13328 wxDC *arg1 = (wxDC *) 0 ;
13329 wxPoint *arg2 = 0 ;
13330 int arg3 ;
13331 wxPoint temp2 ;
13332 PyObject * obj0 = 0 ;
13333 PyObject * obj1 = 0 ;
13334 PyObject * obj2 = 0 ;
13335 char *kwnames[] = {
13336 (char *) "self",(char *) "pt",(char *) "radius", NULL
13337 };
13338
13339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13341 if (SWIG_arg_fail(1)) SWIG_fail;
13342 {
13343 arg2 = &temp2;
13344 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13345 }
13346 {
13347 arg3 = (int)(SWIG_As_int(obj2));
13348 if (SWIG_arg_fail(3)) SWIG_fail;
13349 }
13350 {
13351 PyThreadState* __tstate = wxPyBeginAllowThreads();
13352 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13353
13354 wxPyEndAllowThreads(__tstate);
13355 if (PyErr_Occurred()) SWIG_fail;
13356 }
13357 Py_INCREF(Py_None); resultobj = Py_None;
13358 return resultobj;
13359 fail:
13360 return NULL;
13361 }
13362
13363
13364 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
13365 PyObject *resultobj;
13366 wxDC *arg1 = (wxDC *) 0 ;
13367 int arg2 ;
13368 int arg3 ;
13369 int arg4 ;
13370 int arg5 ;
13371 PyObject * obj0 = 0 ;
13372 PyObject * obj1 = 0 ;
13373 PyObject * obj2 = 0 ;
13374 PyObject * obj3 = 0 ;
13375 PyObject * obj4 = 0 ;
13376 char *kwnames[] = {
13377 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13378 };
13379
13380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13382 if (SWIG_arg_fail(1)) SWIG_fail;
13383 {
13384 arg2 = (int)(SWIG_As_int(obj1));
13385 if (SWIG_arg_fail(2)) SWIG_fail;
13386 }
13387 {
13388 arg3 = (int)(SWIG_As_int(obj2));
13389 if (SWIG_arg_fail(3)) SWIG_fail;
13390 }
13391 {
13392 arg4 = (int)(SWIG_As_int(obj3));
13393 if (SWIG_arg_fail(4)) SWIG_fail;
13394 }
13395 {
13396 arg5 = (int)(SWIG_As_int(obj4));
13397 if (SWIG_arg_fail(5)) SWIG_fail;
13398 }
13399 {
13400 PyThreadState* __tstate = wxPyBeginAllowThreads();
13401 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
13402
13403 wxPyEndAllowThreads(__tstate);
13404 if (PyErr_Occurred()) SWIG_fail;
13405 }
13406 Py_INCREF(Py_None); resultobj = Py_None;
13407 return resultobj;
13408 fail:
13409 return NULL;
13410 }
13411
13412
13413 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
13414 PyObject *resultobj;
13415 wxDC *arg1 = (wxDC *) 0 ;
13416 wxRect *arg2 = 0 ;
13417 wxRect temp2 ;
13418 PyObject * obj0 = 0 ;
13419 PyObject * obj1 = 0 ;
13420 char *kwnames[] = {
13421 (char *) "self",(char *) "rect", NULL
13422 };
13423
13424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
13425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13426 if (SWIG_arg_fail(1)) SWIG_fail;
13427 {
13428 arg2 = &temp2;
13429 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13430 }
13431 {
13432 PyThreadState* __tstate = wxPyBeginAllowThreads();
13433 (arg1)->DrawEllipse((wxRect const &)*arg2);
13434
13435 wxPyEndAllowThreads(__tstate);
13436 if (PyErr_Occurred()) SWIG_fail;
13437 }
13438 Py_INCREF(Py_None); resultobj = Py_None;
13439 return resultobj;
13440 fail:
13441 return NULL;
13442 }
13443
13444
13445 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13446 PyObject *resultobj;
13447 wxDC *arg1 = (wxDC *) 0 ;
13448 wxPoint *arg2 = 0 ;
13449 wxSize *arg3 = 0 ;
13450 wxPoint temp2 ;
13451 wxSize temp3 ;
13452 PyObject * obj0 = 0 ;
13453 PyObject * obj1 = 0 ;
13454 PyObject * obj2 = 0 ;
13455 char *kwnames[] = {
13456 (char *) "self",(char *) "pt",(char *) "sz", NULL
13457 };
13458
13459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13461 if (SWIG_arg_fail(1)) SWIG_fail;
13462 {
13463 arg2 = &temp2;
13464 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13465 }
13466 {
13467 arg3 = &temp3;
13468 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13469 }
13470 {
13471 PyThreadState* __tstate = wxPyBeginAllowThreads();
13472 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
13473
13474 wxPyEndAllowThreads(__tstate);
13475 if (PyErr_Occurred()) SWIG_fail;
13476 }
13477 Py_INCREF(Py_None); resultobj = Py_None;
13478 return resultobj;
13479 fail:
13480 return NULL;
13481 }
13482
13483
13484 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13485 PyObject *resultobj;
13486 wxDC *arg1 = (wxDC *) 0 ;
13487 wxIcon *arg2 = 0 ;
13488 int arg3 ;
13489 int arg4 ;
13490 PyObject * obj0 = 0 ;
13491 PyObject * obj1 = 0 ;
13492 PyObject * obj2 = 0 ;
13493 PyObject * obj3 = 0 ;
13494 char *kwnames[] = {
13495 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
13496 };
13497
13498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13500 if (SWIG_arg_fail(1)) SWIG_fail;
13501 {
13502 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13503 if (SWIG_arg_fail(2)) SWIG_fail;
13504 if (arg2 == NULL) {
13505 SWIG_null_ref("wxIcon");
13506 }
13507 if (SWIG_arg_fail(2)) SWIG_fail;
13508 }
13509 {
13510 arg3 = (int)(SWIG_As_int(obj2));
13511 if (SWIG_arg_fail(3)) SWIG_fail;
13512 }
13513 {
13514 arg4 = (int)(SWIG_As_int(obj3));
13515 if (SWIG_arg_fail(4)) SWIG_fail;
13516 }
13517 {
13518 PyThreadState* __tstate = wxPyBeginAllowThreads();
13519 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
13520
13521 wxPyEndAllowThreads(__tstate);
13522 if (PyErr_Occurred()) SWIG_fail;
13523 }
13524 Py_INCREF(Py_None); resultobj = Py_None;
13525 return resultobj;
13526 fail:
13527 return NULL;
13528 }
13529
13530
13531 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13532 PyObject *resultobj;
13533 wxDC *arg1 = (wxDC *) 0 ;
13534 wxIcon *arg2 = 0 ;
13535 wxPoint *arg3 = 0 ;
13536 wxPoint temp3 ;
13537 PyObject * obj0 = 0 ;
13538 PyObject * obj1 = 0 ;
13539 PyObject * obj2 = 0 ;
13540 char *kwnames[] = {
13541 (char *) "self",(char *) "icon",(char *) "pt", NULL
13542 };
13543
13544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13546 if (SWIG_arg_fail(1)) SWIG_fail;
13547 {
13548 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13549 if (SWIG_arg_fail(2)) SWIG_fail;
13550 if (arg2 == NULL) {
13551 SWIG_null_ref("wxIcon");
13552 }
13553 if (SWIG_arg_fail(2)) SWIG_fail;
13554 }
13555 {
13556 arg3 = &temp3;
13557 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13558 }
13559 {
13560 PyThreadState* __tstate = wxPyBeginAllowThreads();
13561 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint 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_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13574 PyObject *resultobj;
13575 wxDC *arg1 = (wxDC *) 0 ;
13576 wxBitmap *arg2 = 0 ;
13577 int arg3 ;
13578 int arg4 ;
13579 bool arg5 = (bool) false ;
13580 PyObject * obj0 = 0 ;
13581 PyObject * obj1 = 0 ;
13582 PyObject * obj2 = 0 ;
13583 PyObject * obj3 = 0 ;
13584 PyObject * obj4 = 0 ;
13585 char *kwnames[] = {
13586 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
13587 };
13588
13589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13591 if (SWIG_arg_fail(1)) SWIG_fail;
13592 {
13593 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13594 if (SWIG_arg_fail(2)) SWIG_fail;
13595 if (arg2 == NULL) {
13596 SWIG_null_ref("wxBitmap");
13597 }
13598 if (SWIG_arg_fail(2)) SWIG_fail;
13599 }
13600 {
13601 arg3 = (int)(SWIG_As_int(obj2));
13602 if (SWIG_arg_fail(3)) SWIG_fail;
13603 }
13604 {
13605 arg4 = (int)(SWIG_As_int(obj3));
13606 if (SWIG_arg_fail(4)) SWIG_fail;
13607 }
13608 if (obj4) {
13609 {
13610 arg5 = (bool)(SWIG_As_bool(obj4));
13611 if (SWIG_arg_fail(5)) SWIG_fail;
13612 }
13613 }
13614 {
13615 PyThreadState* __tstate = wxPyBeginAllowThreads();
13616 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
13617
13618 wxPyEndAllowThreads(__tstate);
13619 if (PyErr_Occurred()) SWIG_fail;
13620 }
13621 Py_INCREF(Py_None); resultobj = Py_None;
13622 return resultobj;
13623 fail:
13624 return NULL;
13625 }
13626
13627
13628 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13629 PyObject *resultobj;
13630 wxDC *arg1 = (wxDC *) 0 ;
13631 wxBitmap *arg2 = 0 ;
13632 wxPoint *arg3 = 0 ;
13633 bool arg4 = (bool) false ;
13634 wxPoint temp3 ;
13635 PyObject * obj0 = 0 ;
13636 PyObject * obj1 = 0 ;
13637 PyObject * obj2 = 0 ;
13638 PyObject * obj3 = 0 ;
13639 char *kwnames[] = {
13640 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
13641 };
13642
13643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13645 if (SWIG_arg_fail(1)) SWIG_fail;
13646 {
13647 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13648 if (SWIG_arg_fail(2)) SWIG_fail;
13649 if (arg2 == NULL) {
13650 SWIG_null_ref("wxBitmap");
13651 }
13652 if (SWIG_arg_fail(2)) SWIG_fail;
13653 }
13654 {
13655 arg3 = &temp3;
13656 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13657 }
13658 if (obj3) {
13659 {
13660 arg4 = (bool)(SWIG_As_bool(obj3));
13661 if (SWIG_arg_fail(4)) SWIG_fail;
13662 }
13663 }
13664 {
13665 PyThreadState* __tstate = wxPyBeginAllowThreads();
13666 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
13667
13668 wxPyEndAllowThreads(__tstate);
13669 if (PyErr_Occurred()) SWIG_fail;
13670 }
13671 Py_INCREF(Py_None); resultobj = Py_None;
13672 return resultobj;
13673 fail:
13674 return NULL;
13675 }
13676
13677
13678 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
13679 PyObject *resultobj;
13680 wxDC *arg1 = (wxDC *) 0 ;
13681 wxString *arg2 = 0 ;
13682 int arg3 ;
13683 int arg4 ;
13684 bool temp2 = false ;
13685 PyObject * obj0 = 0 ;
13686 PyObject * obj1 = 0 ;
13687 PyObject * obj2 = 0 ;
13688 PyObject * obj3 = 0 ;
13689 char *kwnames[] = {
13690 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
13691 };
13692
13693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13695 if (SWIG_arg_fail(1)) SWIG_fail;
13696 {
13697 arg2 = wxString_in_helper(obj1);
13698 if (arg2 == NULL) SWIG_fail;
13699 temp2 = true;
13700 }
13701 {
13702 arg3 = (int)(SWIG_As_int(obj2));
13703 if (SWIG_arg_fail(3)) SWIG_fail;
13704 }
13705 {
13706 arg4 = (int)(SWIG_As_int(obj3));
13707 if (SWIG_arg_fail(4)) SWIG_fail;
13708 }
13709 {
13710 PyThreadState* __tstate = wxPyBeginAllowThreads();
13711 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
13712
13713 wxPyEndAllowThreads(__tstate);
13714 if (PyErr_Occurred()) SWIG_fail;
13715 }
13716 Py_INCREF(Py_None); resultobj = Py_None;
13717 {
13718 if (temp2)
13719 delete arg2;
13720 }
13721 return resultobj;
13722 fail:
13723 {
13724 if (temp2)
13725 delete arg2;
13726 }
13727 return NULL;
13728 }
13729
13730
13731 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13732 PyObject *resultobj;
13733 wxDC *arg1 = (wxDC *) 0 ;
13734 wxString *arg2 = 0 ;
13735 wxPoint *arg3 = 0 ;
13736 bool temp2 = false ;
13737 wxPoint temp3 ;
13738 PyObject * obj0 = 0 ;
13739 PyObject * obj1 = 0 ;
13740 PyObject * obj2 = 0 ;
13741 char *kwnames[] = {
13742 (char *) "self",(char *) "text",(char *) "pt", NULL
13743 };
13744
13745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13747 if (SWIG_arg_fail(1)) SWIG_fail;
13748 {
13749 arg2 = wxString_in_helper(obj1);
13750 if (arg2 == NULL) SWIG_fail;
13751 temp2 = true;
13752 }
13753 {
13754 arg3 = &temp3;
13755 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13756 }
13757 {
13758 PyThreadState* __tstate = wxPyBeginAllowThreads();
13759 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
13760
13761 wxPyEndAllowThreads(__tstate);
13762 if (PyErr_Occurred()) SWIG_fail;
13763 }
13764 Py_INCREF(Py_None); resultobj = Py_None;
13765 {
13766 if (temp2)
13767 delete arg2;
13768 }
13769 return resultobj;
13770 fail:
13771 {
13772 if (temp2)
13773 delete arg2;
13774 }
13775 return NULL;
13776 }
13777
13778
13779 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
13780 PyObject *resultobj;
13781 wxDC *arg1 = (wxDC *) 0 ;
13782 wxString *arg2 = 0 ;
13783 int arg3 ;
13784 int arg4 ;
13785 double arg5 ;
13786 bool temp2 = false ;
13787 PyObject * obj0 = 0 ;
13788 PyObject * obj1 = 0 ;
13789 PyObject * obj2 = 0 ;
13790 PyObject * obj3 = 0 ;
13791 PyObject * obj4 = 0 ;
13792 char *kwnames[] = {
13793 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
13794 };
13795
13796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13798 if (SWIG_arg_fail(1)) SWIG_fail;
13799 {
13800 arg2 = wxString_in_helper(obj1);
13801 if (arg2 == NULL) SWIG_fail;
13802 temp2 = true;
13803 }
13804 {
13805 arg3 = (int)(SWIG_As_int(obj2));
13806 if (SWIG_arg_fail(3)) SWIG_fail;
13807 }
13808 {
13809 arg4 = (int)(SWIG_As_int(obj3));
13810 if (SWIG_arg_fail(4)) SWIG_fail;
13811 }
13812 {
13813 arg5 = (double)(SWIG_As_double(obj4));
13814 if (SWIG_arg_fail(5)) SWIG_fail;
13815 }
13816 {
13817 PyThreadState* __tstate = wxPyBeginAllowThreads();
13818 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
13819
13820 wxPyEndAllowThreads(__tstate);
13821 if (PyErr_Occurred()) SWIG_fail;
13822 }
13823 Py_INCREF(Py_None); resultobj = Py_None;
13824 {
13825 if (temp2)
13826 delete arg2;
13827 }
13828 return resultobj;
13829 fail:
13830 {
13831 if (temp2)
13832 delete arg2;
13833 }
13834 return NULL;
13835 }
13836
13837
13838 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13839 PyObject *resultobj;
13840 wxDC *arg1 = (wxDC *) 0 ;
13841 wxString *arg2 = 0 ;
13842 wxPoint *arg3 = 0 ;
13843 double arg4 ;
13844 bool temp2 = false ;
13845 wxPoint temp3 ;
13846 PyObject * obj0 = 0 ;
13847 PyObject * obj1 = 0 ;
13848 PyObject * obj2 = 0 ;
13849 PyObject * obj3 = 0 ;
13850 char *kwnames[] = {
13851 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
13852 };
13853
13854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13856 if (SWIG_arg_fail(1)) SWIG_fail;
13857 {
13858 arg2 = wxString_in_helper(obj1);
13859 if (arg2 == NULL) SWIG_fail;
13860 temp2 = true;
13861 }
13862 {
13863 arg3 = &temp3;
13864 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13865 }
13866 {
13867 arg4 = (double)(SWIG_As_double(obj3));
13868 if (SWIG_arg_fail(4)) SWIG_fail;
13869 }
13870 {
13871 PyThreadState* __tstate = wxPyBeginAllowThreads();
13872 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
13873
13874 wxPyEndAllowThreads(__tstate);
13875 if (PyErr_Occurred()) SWIG_fail;
13876 }
13877 Py_INCREF(Py_None); resultobj = Py_None;
13878 {
13879 if (temp2)
13880 delete arg2;
13881 }
13882 return resultobj;
13883 fail:
13884 {
13885 if (temp2)
13886 delete arg2;
13887 }
13888 return NULL;
13889 }
13890
13891
13892 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
13893 PyObject *resultobj;
13894 wxDC *arg1 = (wxDC *) 0 ;
13895 int arg2 ;
13896 int arg3 ;
13897 int arg4 ;
13898 int arg5 ;
13899 wxDC *arg6 = (wxDC *) 0 ;
13900 int arg7 ;
13901 int arg8 ;
13902 int arg9 = (int) wxCOPY ;
13903 bool arg10 = (bool) false ;
13904 int arg11 = (int) -1 ;
13905 int arg12 = (int) -1 ;
13906 bool result;
13907 PyObject * obj0 = 0 ;
13908 PyObject * obj1 = 0 ;
13909 PyObject * obj2 = 0 ;
13910 PyObject * obj3 = 0 ;
13911 PyObject * obj4 = 0 ;
13912 PyObject * obj5 = 0 ;
13913 PyObject * obj6 = 0 ;
13914 PyObject * obj7 = 0 ;
13915 PyObject * obj8 = 0 ;
13916 PyObject * obj9 = 0 ;
13917 PyObject * obj10 = 0 ;
13918 PyObject * obj11 = 0 ;
13919 char *kwnames[] = {
13920 (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
13921 };
13922
13923 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;
13924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13925 if (SWIG_arg_fail(1)) SWIG_fail;
13926 {
13927 arg2 = (int)(SWIG_As_int(obj1));
13928 if (SWIG_arg_fail(2)) SWIG_fail;
13929 }
13930 {
13931 arg3 = (int)(SWIG_As_int(obj2));
13932 if (SWIG_arg_fail(3)) SWIG_fail;
13933 }
13934 {
13935 arg4 = (int)(SWIG_As_int(obj3));
13936 if (SWIG_arg_fail(4)) SWIG_fail;
13937 }
13938 {
13939 arg5 = (int)(SWIG_As_int(obj4));
13940 if (SWIG_arg_fail(5)) SWIG_fail;
13941 }
13942 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13943 if (SWIG_arg_fail(6)) SWIG_fail;
13944 {
13945 arg7 = (int)(SWIG_As_int(obj6));
13946 if (SWIG_arg_fail(7)) SWIG_fail;
13947 }
13948 {
13949 arg8 = (int)(SWIG_As_int(obj7));
13950 if (SWIG_arg_fail(8)) SWIG_fail;
13951 }
13952 if (obj8) {
13953 {
13954 arg9 = (int)(SWIG_As_int(obj8));
13955 if (SWIG_arg_fail(9)) SWIG_fail;
13956 }
13957 }
13958 if (obj9) {
13959 {
13960 arg10 = (bool)(SWIG_As_bool(obj9));
13961 if (SWIG_arg_fail(10)) SWIG_fail;
13962 }
13963 }
13964 if (obj10) {
13965 {
13966 arg11 = (int)(SWIG_As_int(obj10));
13967 if (SWIG_arg_fail(11)) SWIG_fail;
13968 }
13969 }
13970 if (obj11) {
13971 {
13972 arg12 = (int)(SWIG_As_int(obj11));
13973 if (SWIG_arg_fail(12)) SWIG_fail;
13974 }
13975 }
13976 {
13977 PyThreadState* __tstate = wxPyBeginAllowThreads();
13978 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
13979
13980 wxPyEndAllowThreads(__tstate);
13981 if (PyErr_Occurred()) SWIG_fail;
13982 }
13983 {
13984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13985 }
13986 return resultobj;
13987 fail:
13988 return NULL;
13989 }
13990
13991
13992 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13993 PyObject *resultobj;
13994 wxDC *arg1 = (wxDC *) 0 ;
13995 wxPoint *arg2 = 0 ;
13996 wxSize *arg3 = 0 ;
13997 wxDC *arg4 = (wxDC *) 0 ;
13998 wxPoint *arg5 = 0 ;
13999 int arg6 = (int) wxCOPY ;
14000 bool arg7 = (bool) false ;
14001 wxPoint const &arg8_defvalue = wxDefaultPosition ;
14002 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
14003 bool result;
14004 wxPoint temp2 ;
14005 wxSize temp3 ;
14006 wxPoint temp5 ;
14007 wxPoint temp8 ;
14008 PyObject * obj0 = 0 ;
14009 PyObject * obj1 = 0 ;
14010 PyObject * obj2 = 0 ;
14011 PyObject * obj3 = 0 ;
14012 PyObject * obj4 = 0 ;
14013 PyObject * obj5 = 0 ;
14014 PyObject * obj6 = 0 ;
14015 PyObject * obj7 = 0 ;
14016 char *kwnames[] = {
14017 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
14018 };
14019
14020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
14021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14022 if (SWIG_arg_fail(1)) SWIG_fail;
14023 {
14024 arg2 = &temp2;
14025 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14026 }
14027 {
14028 arg3 = &temp3;
14029 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14030 }
14031 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14032 if (SWIG_arg_fail(4)) SWIG_fail;
14033 {
14034 arg5 = &temp5;
14035 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14036 }
14037 if (obj5) {
14038 {
14039 arg6 = (int)(SWIG_As_int(obj5));
14040 if (SWIG_arg_fail(6)) SWIG_fail;
14041 }
14042 }
14043 if (obj6) {
14044 {
14045 arg7 = (bool)(SWIG_As_bool(obj6));
14046 if (SWIG_arg_fail(7)) SWIG_fail;
14047 }
14048 }
14049 if (obj7) {
14050 {
14051 arg8 = &temp8;
14052 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14053 }
14054 }
14055 {
14056 PyThreadState* __tstate = wxPyBeginAllowThreads();
14057 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14058
14059 wxPyEndAllowThreads(__tstate);
14060 if (PyErr_Occurred()) SWIG_fail;
14061 }
14062 {
14063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14064 }
14065 return resultobj;
14066 fail:
14067 return NULL;
14068 }
14069
14070
14071 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14072 PyObject *resultobj;
14073 wxDC *arg1 = (wxDC *) 0 ;
14074 int arg2 ;
14075 int arg3 ;
14076 int arg4 ;
14077 int arg5 ;
14078 PyObject * obj0 = 0 ;
14079 PyObject * obj1 = 0 ;
14080 PyObject * obj2 = 0 ;
14081 PyObject * obj3 = 0 ;
14082 PyObject * obj4 = 0 ;
14083 char *kwnames[] = {
14084 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14085 };
14086
14087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14089 if (SWIG_arg_fail(1)) SWIG_fail;
14090 {
14091 arg2 = (int)(SWIG_As_int(obj1));
14092 if (SWIG_arg_fail(2)) SWIG_fail;
14093 }
14094 {
14095 arg3 = (int)(SWIG_As_int(obj2));
14096 if (SWIG_arg_fail(3)) SWIG_fail;
14097 }
14098 {
14099 arg4 = (int)(SWIG_As_int(obj3));
14100 if (SWIG_arg_fail(4)) SWIG_fail;
14101 }
14102 {
14103 arg5 = (int)(SWIG_As_int(obj4));
14104 if (SWIG_arg_fail(5)) SWIG_fail;
14105 }
14106 {
14107 PyThreadState* __tstate = wxPyBeginAllowThreads();
14108 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14109
14110 wxPyEndAllowThreads(__tstate);
14111 if (PyErr_Occurred()) SWIG_fail;
14112 }
14113 Py_INCREF(Py_None); resultobj = Py_None;
14114 return resultobj;
14115 fail:
14116 return NULL;
14117 }
14118
14119
14120 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14121 PyObject *resultobj;
14122 wxDC *arg1 = (wxDC *) 0 ;
14123 wxPoint *arg2 = 0 ;
14124 wxSize *arg3 = 0 ;
14125 wxPoint temp2 ;
14126 wxSize temp3 ;
14127 PyObject * obj0 = 0 ;
14128 PyObject * obj1 = 0 ;
14129 PyObject * obj2 = 0 ;
14130 char *kwnames[] = {
14131 (char *) "self",(char *) "pt",(char *) "sz", NULL
14132 };
14133
14134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14136 if (SWIG_arg_fail(1)) SWIG_fail;
14137 {
14138 arg2 = &temp2;
14139 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14140 }
14141 {
14142 arg3 = &temp3;
14143 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14144 }
14145 {
14146 PyThreadState* __tstate = wxPyBeginAllowThreads();
14147 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14148
14149 wxPyEndAllowThreads(__tstate);
14150 if (PyErr_Occurred()) SWIG_fail;
14151 }
14152 Py_INCREF(Py_None); resultobj = Py_None;
14153 return resultobj;
14154 fail:
14155 return NULL;
14156 }
14157
14158
14159 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14160 PyObject *resultobj;
14161 wxDC *arg1 = (wxDC *) 0 ;
14162 wxRegion *arg2 = 0 ;
14163 PyObject * obj0 = 0 ;
14164 PyObject * obj1 = 0 ;
14165 char *kwnames[] = {
14166 (char *) "self",(char *) "region", NULL
14167 };
14168
14169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14171 if (SWIG_arg_fail(1)) SWIG_fail;
14172 {
14173 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14174 if (SWIG_arg_fail(2)) SWIG_fail;
14175 if (arg2 == NULL) {
14176 SWIG_null_ref("wxRegion");
14177 }
14178 if (SWIG_arg_fail(2)) SWIG_fail;
14179 }
14180 {
14181 PyThreadState* __tstate = wxPyBeginAllowThreads();
14182 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14183
14184 wxPyEndAllowThreads(__tstate);
14185 if (PyErr_Occurred()) SWIG_fail;
14186 }
14187 Py_INCREF(Py_None); resultobj = Py_None;
14188 return resultobj;
14189 fail:
14190 return NULL;
14191 }
14192
14193
14194 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14195 PyObject *resultobj;
14196 wxDC *arg1 = (wxDC *) 0 ;
14197 wxRect *arg2 = 0 ;
14198 wxRect temp2 ;
14199 PyObject * obj0 = 0 ;
14200 PyObject * obj1 = 0 ;
14201 char *kwnames[] = {
14202 (char *) "self",(char *) "rect", NULL
14203 };
14204
14205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14207 if (SWIG_arg_fail(1)) SWIG_fail;
14208 {
14209 arg2 = &temp2;
14210 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14211 }
14212 {
14213 PyThreadState* __tstate = wxPyBeginAllowThreads();
14214 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14215
14216 wxPyEndAllowThreads(__tstate);
14217 if (PyErr_Occurred()) SWIG_fail;
14218 }
14219 Py_INCREF(Py_None); resultobj = Py_None;
14220 return resultobj;
14221 fail:
14222 return NULL;
14223 }
14224
14225
14226 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14227 PyObject *resultobj;
14228 wxDC *arg1 = (wxDC *) 0 ;
14229 int arg2 ;
14230 wxPoint *arg3 = (wxPoint *) 0 ;
14231 int arg4 = (int) 0 ;
14232 int arg5 = (int) 0 ;
14233 PyObject * obj0 = 0 ;
14234 PyObject * obj1 = 0 ;
14235 PyObject * obj2 = 0 ;
14236 PyObject * obj3 = 0 ;
14237 char *kwnames[] = {
14238 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14239 };
14240
14241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14243 if (SWIG_arg_fail(1)) SWIG_fail;
14244 {
14245 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14246 if (arg3 == NULL) SWIG_fail;
14247 }
14248 if (obj2) {
14249 {
14250 arg4 = (int)(SWIG_As_int(obj2));
14251 if (SWIG_arg_fail(4)) SWIG_fail;
14252 }
14253 }
14254 if (obj3) {
14255 {
14256 arg5 = (int)(SWIG_As_int(obj3));
14257 if (SWIG_arg_fail(5)) SWIG_fail;
14258 }
14259 }
14260 {
14261 PyThreadState* __tstate = wxPyBeginAllowThreads();
14262 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14263
14264 wxPyEndAllowThreads(__tstate);
14265 if (PyErr_Occurred()) SWIG_fail;
14266 }
14267 Py_INCREF(Py_None); resultobj = Py_None;
14268 {
14269 if (arg3) delete [] arg3;
14270 }
14271 return resultobj;
14272 fail:
14273 {
14274 if (arg3) delete [] arg3;
14275 }
14276 return NULL;
14277 }
14278
14279
14280 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14281 PyObject *resultobj;
14282 wxDC *arg1 = (wxDC *) 0 ;
14283 int arg2 ;
14284 wxPoint *arg3 = (wxPoint *) 0 ;
14285 int arg4 = (int) 0 ;
14286 int arg5 = (int) 0 ;
14287 int arg6 = (int) wxODDEVEN_RULE ;
14288 PyObject * obj0 = 0 ;
14289 PyObject * obj1 = 0 ;
14290 PyObject * obj2 = 0 ;
14291 PyObject * obj3 = 0 ;
14292 PyObject * obj4 = 0 ;
14293 char *kwnames[] = {
14294 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14295 };
14296
14297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14299 if (SWIG_arg_fail(1)) SWIG_fail;
14300 {
14301 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14302 if (arg3 == NULL) SWIG_fail;
14303 }
14304 if (obj2) {
14305 {
14306 arg4 = (int)(SWIG_As_int(obj2));
14307 if (SWIG_arg_fail(4)) SWIG_fail;
14308 }
14309 }
14310 if (obj3) {
14311 {
14312 arg5 = (int)(SWIG_As_int(obj3));
14313 if (SWIG_arg_fail(5)) SWIG_fail;
14314 }
14315 }
14316 if (obj4) {
14317 {
14318 arg6 = (int)(SWIG_As_int(obj4));
14319 if (SWIG_arg_fail(6)) SWIG_fail;
14320 }
14321 }
14322 {
14323 PyThreadState* __tstate = wxPyBeginAllowThreads();
14324 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14325
14326 wxPyEndAllowThreads(__tstate);
14327 if (PyErr_Occurred()) SWIG_fail;
14328 }
14329 Py_INCREF(Py_None); resultobj = Py_None;
14330 {
14331 if (arg3) delete [] arg3;
14332 }
14333 return resultobj;
14334 fail:
14335 {
14336 if (arg3) delete [] arg3;
14337 }
14338 return NULL;
14339 }
14340
14341
14342 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14343 PyObject *resultobj;
14344 wxDC *arg1 = (wxDC *) 0 ;
14345 wxString *arg2 = 0 ;
14346 wxRect *arg3 = 0 ;
14347 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14348 int arg5 = (int) -1 ;
14349 bool temp2 = false ;
14350 wxRect temp3 ;
14351 PyObject * obj0 = 0 ;
14352 PyObject * obj1 = 0 ;
14353 PyObject * obj2 = 0 ;
14354 PyObject * obj3 = 0 ;
14355 PyObject * obj4 = 0 ;
14356 char *kwnames[] = {
14357 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14358 };
14359
14360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14362 if (SWIG_arg_fail(1)) SWIG_fail;
14363 {
14364 arg2 = wxString_in_helper(obj1);
14365 if (arg2 == NULL) SWIG_fail;
14366 temp2 = true;
14367 }
14368 {
14369 arg3 = &temp3;
14370 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
14371 }
14372 if (obj3) {
14373 {
14374 arg4 = (int)(SWIG_As_int(obj3));
14375 if (SWIG_arg_fail(4)) SWIG_fail;
14376 }
14377 }
14378 if (obj4) {
14379 {
14380 arg5 = (int)(SWIG_As_int(obj4));
14381 if (SWIG_arg_fail(5)) SWIG_fail;
14382 }
14383 }
14384 {
14385 PyThreadState* __tstate = wxPyBeginAllowThreads();
14386 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
14387
14388 wxPyEndAllowThreads(__tstate);
14389 if (PyErr_Occurred()) SWIG_fail;
14390 }
14391 Py_INCREF(Py_None); resultobj = Py_None;
14392 {
14393 if (temp2)
14394 delete arg2;
14395 }
14396 return resultobj;
14397 fail:
14398 {
14399 if (temp2)
14400 delete arg2;
14401 }
14402 return NULL;
14403 }
14404
14405
14406 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14407 PyObject *resultobj;
14408 wxDC *arg1 = (wxDC *) 0 ;
14409 wxString *arg2 = 0 ;
14410 wxBitmap *arg3 = 0 ;
14411 wxRect *arg4 = 0 ;
14412 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14413 int arg6 = (int) -1 ;
14414 wxRect result;
14415 bool temp2 = false ;
14416 wxRect temp4 ;
14417 PyObject * obj0 = 0 ;
14418 PyObject * obj1 = 0 ;
14419 PyObject * obj2 = 0 ;
14420 PyObject * obj3 = 0 ;
14421 PyObject * obj4 = 0 ;
14422 PyObject * obj5 = 0 ;
14423 char *kwnames[] = {
14424 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14425 };
14426
14427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14429 if (SWIG_arg_fail(1)) SWIG_fail;
14430 {
14431 arg2 = wxString_in_helper(obj1);
14432 if (arg2 == NULL) SWIG_fail;
14433 temp2 = true;
14434 }
14435 {
14436 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14437 if (SWIG_arg_fail(3)) SWIG_fail;
14438 if (arg3 == NULL) {
14439 SWIG_null_ref("wxBitmap");
14440 }
14441 if (SWIG_arg_fail(3)) SWIG_fail;
14442 }
14443 {
14444 arg4 = &temp4;
14445 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
14446 }
14447 if (obj4) {
14448 {
14449 arg5 = (int)(SWIG_As_int(obj4));
14450 if (SWIG_arg_fail(5)) SWIG_fail;
14451 }
14452 }
14453 if (obj5) {
14454 {
14455 arg6 = (int)(SWIG_As_int(obj5));
14456 if (SWIG_arg_fail(6)) SWIG_fail;
14457 }
14458 }
14459 {
14460 PyThreadState* __tstate = wxPyBeginAllowThreads();
14461 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
14462
14463 wxPyEndAllowThreads(__tstate);
14464 if (PyErr_Occurred()) SWIG_fail;
14465 }
14466 {
14467 wxRect * resultptr;
14468 resultptr = new wxRect((wxRect &)(result));
14469 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14470 }
14471 {
14472 if (temp2)
14473 delete arg2;
14474 }
14475 return resultobj;
14476 fail:
14477 {
14478 if (temp2)
14479 delete arg2;
14480 }
14481 return NULL;
14482 }
14483
14484
14485 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
14486 PyObject *resultobj;
14487 wxDC *arg1 = (wxDC *) 0 ;
14488 int arg2 ;
14489 wxPoint *arg3 = (wxPoint *) 0 ;
14490 PyObject * obj0 = 0 ;
14491 PyObject * obj1 = 0 ;
14492 char *kwnames[] = {
14493 (char *) "self",(char *) "points", NULL
14494 };
14495
14496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
14497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14498 if (SWIG_arg_fail(1)) SWIG_fail;
14499 {
14500 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14501 if (arg3 == NULL) SWIG_fail;
14502 }
14503 {
14504 PyThreadState* __tstate = wxPyBeginAllowThreads();
14505 (arg1)->DrawSpline(arg2,arg3);
14506
14507 wxPyEndAllowThreads(__tstate);
14508 if (PyErr_Occurred()) SWIG_fail;
14509 }
14510 Py_INCREF(Py_None); resultobj = Py_None;
14511 {
14512 if (arg3) delete [] arg3;
14513 }
14514 return resultobj;
14515 fail:
14516 {
14517 if (arg3) delete [] arg3;
14518 }
14519 return NULL;
14520 }
14521
14522
14523 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
14524 PyObject *resultobj;
14525 wxDC *arg1 = (wxDC *) 0 ;
14526 PyObject * obj0 = 0 ;
14527 char *kwnames[] = {
14528 (char *) "self", NULL
14529 };
14530
14531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
14532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14533 if (SWIG_arg_fail(1)) SWIG_fail;
14534 {
14535 PyThreadState* __tstate = wxPyBeginAllowThreads();
14536 (arg1)->Clear();
14537
14538 wxPyEndAllowThreads(__tstate);
14539 if (PyErr_Occurred()) SWIG_fail;
14540 }
14541 Py_INCREF(Py_None); resultobj = Py_None;
14542 return resultobj;
14543 fail:
14544 return NULL;
14545 }
14546
14547
14548 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14549 PyObject *resultobj;
14550 wxDC *arg1 = (wxDC *) 0 ;
14551 wxString *arg2 = 0 ;
14552 bool result;
14553 bool temp2 = false ;
14554 PyObject * obj0 = 0 ;
14555 PyObject * obj1 = 0 ;
14556 char *kwnames[] = {
14557 (char *) "self",(char *) "message", NULL
14558 };
14559
14560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
14561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14562 if (SWIG_arg_fail(1)) SWIG_fail;
14563 {
14564 arg2 = wxString_in_helper(obj1);
14565 if (arg2 == NULL) SWIG_fail;
14566 temp2 = true;
14567 }
14568 {
14569 PyThreadState* __tstate = wxPyBeginAllowThreads();
14570 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
14571
14572 wxPyEndAllowThreads(__tstate);
14573 if (PyErr_Occurred()) SWIG_fail;
14574 }
14575 {
14576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14577 }
14578 {
14579 if (temp2)
14580 delete arg2;
14581 }
14582 return resultobj;
14583 fail:
14584 {
14585 if (temp2)
14586 delete arg2;
14587 }
14588 return NULL;
14589 }
14590
14591
14592 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14593 PyObject *resultobj;
14594 wxDC *arg1 = (wxDC *) 0 ;
14595 PyObject * obj0 = 0 ;
14596 char *kwnames[] = {
14597 (char *) "self", NULL
14598 };
14599
14600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
14601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14602 if (SWIG_arg_fail(1)) SWIG_fail;
14603 {
14604 PyThreadState* __tstate = wxPyBeginAllowThreads();
14605 (arg1)->EndDoc();
14606
14607 wxPyEndAllowThreads(__tstate);
14608 if (PyErr_Occurred()) SWIG_fail;
14609 }
14610 Py_INCREF(Py_None); resultobj = Py_None;
14611 return resultobj;
14612 fail:
14613 return NULL;
14614 }
14615
14616
14617 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
14618 PyObject *resultobj;
14619 wxDC *arg1 = (wxDC *) 0 ;
14620 PyObject * obj0 = 0 ;
14621 char *kwnames[] = {
14622 (char *) "self", NULL
14623 };
14624
14625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
14626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14627 if (SWIG_arg_fail(1)) SWIG_fail;
14628 {
14629 PyThreadState* __tstate = wxPyBeginAllowThreads();
14630 (arg1)->StartPage();
14631
14632 wxPyEndAllowThreads(__tstate);
14633 if (PyErr_Occurred()) SWIG_fail;
14634 }
14635 Py_INCREF(Py_None); resultobj = Py_None;
14636 return resultobj;
14637 fail:
14638 return NULL;
14639 }
14640
14641
14642 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
14643 PyObject *resultobj;
14644 wxDC *arg1 = (wxDC *) 0 ;
14645 PyObject * obj0 = 0 ;
14646 char *kwnames[] = {
14647 (char *) "self", NULL
14648 };
14649
14650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
14651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14652 if (SWIG_arg_fail(1)) SWIG_fail;
14653 {
14654 PyThreadState* __tstate = wxPyBeginAllowThreads();
14655 (arg1)->EndPage();
14656
14657 wxPyEndAllowThreads(__tstate);
14658 if (PyErr_Occurred()) SWIG_fail;
14659 }
14660 Py_INCREF(Py_None); resultobj = Py_None;
14661 return resultobj;
14662 fail:
14663 return NULL;
14664 }
14665
14666
14667 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
14668 PyObject *resultobj;
14669 wxDC *arg1 = (wxDC *) 0 ;
14670 wxFont *arg2 = 0 ;
14671 PyObject * obj0 = 0 ;
14672 PyObject * obj1 = 0 ;
14673 char *kwnames[] = {
14674 (char *) "self",(char *) "font", NULL
14675 };
14676
14677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
14678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14679 if (SWIG_arg_fail(1)) SWIG_fail;
14680 {
14681 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14682 if (SWIG_arg_fail(2)) SWIG_fail;
14683 if (arg2 == NULL) {
14684 SWIG_null_ref("wxFont");
14685 }
14686 if (SWIG_arg_fail(2)) SWIG_fail;
14687 }
14688 {
14689 PyThreadState* __tstate = wxPyBeginAllowThreads();
14690 (arg1)->SetFont((wxFont const &)*arg2);
14691
14692 wxPyEndAllowThreads(__tstate);
14693 if (PyErr_Occurred()) SWIG_fail;
14694 }
14695 Py_INCREF(Py_None); resultobj = Py_None;
14696 return resultobj;
14697 fail:
14698 return NULL;
14699 }
14700
14701
14702 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
14703 PyObject *resultobj;
14704 wxDC *arg1 = (wxDC *) 0 ;
14705 wxPen *arg2 = 0 ;
14706 PyObject * obj0 = 0 ;
14707 PyObject * obj1 = 0 ;
14708 char *kwnames[] = {
14709 (char *) "self",(char *) "pen", NULL
14710 };
14711
14712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
14713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14714 if (SWIG_arg_fail(1)) SWIG_fail;
14715 {
14716 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
14717 if (SWIG_arg_fail(2)) SWIG_fail;
14718 if (arg2 == NULL) {
14719 SWIG_null_ref("wxPen");
14720 }
14721 if (SWIG_arg_fail(2)) SWIG_fail;
14722 }
14723 {
14724 PyThreadState* __tstate = wxPyBeginAllowThreads();
14725 (arg1)->SetPen((wxPen const &)*arg2);
14726
14727 wxPyEndAllowThreads(__tstate);
14728 if (PyErr_Occurred()) SWIG_fail;
14729 }
14730 Py_INCREF(Py_None); resultobj = Py_None;
14731 return resultobj;
14732 fail:
14733 return NULL;
14734 }
14735
14736
14737 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
14738 PyObject *resultobj;
14739 wxDC *arg1 = (wxDC *) 0 ;
14740 wxBrush *arg2 = 0 ;
14741 PyObject * obj0 = 0 ;
14742 PyObject * obj1 = 0 ;
14743 char *kwnames[] = {
14744 (char *) "self",(char *) "brush", NULL
14745 };
14746
14747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
14748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14749 if (SWIG_arg_fail(1)) SWIG_fail;
14750 {
14751 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14752 if (SWIG_arg_fail(2)) SWIG_fail;
14753 if (arg2 == NULL) {
14754 SWIG_null_ref("wxBrush");
14755 }
14756 if (SWIG_arg_fail(2)) SWIG_fail;
14757 }
14758 {
14759 PyThreadState* __tstate = wxPyBeginAllowThreads();
14760 (arg1)->SetBrush((wxBrush const &)*arg2);
14761
14762 wxPyEndAllowThreads(__tstate);
14763 if (PyErr_Occurred()) SWIG_fail;
14764 }
14765 Py_INCREF(Py_None); resultobj = Py_None;
14766 return resultobj;
14767 fail:
14768 return NULL;
14769 }
14770
14771
14772 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
14773 PyObject *resultobj;
14774 wxDC *arg1 = (wxDC *) 0 ;
14775 wxBrush *arg2 = 0 ;
14776 PyObject * obj0 = 0 ;
14777 PyObject * obj1 = 0 ;
14778 char *kwnames[] = {
14779 (char *) "self",(char *) "brush", NULL
14780 };
14781
14782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
14783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14784 if (SWIG_arg_fail(1)) SWIG_fail;
14785 {
14786 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14787 if (SWIG_arg_fail(2)) SWIG_fail;
14788 if (arg2 == NULL) {
14789 SWIG_null_ref("wxBrush");
14790 }
14791 if (SWIG_arg_fail(2)) SWIG_fail;
14792 }
14793 {
14794 PyThreadState* __tstate = wxPyBeginAllowThreads();
14795 (arg1)->SetBackground((wxBrush const &)*arg2);
14796
14797 wxPyEndAllowThreads(__tstate);
14798 if (PyErr_Occurred()) SWIG_fail;
14799 }
14800 Py_INCREF(Py_None); resultobj = Py_None;
14801 return resultobj;
14802 fail:
14803 return NULL;
14804 }
14805
14806
14807 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
14808 PyObject *resultobj;
14809 wxDC *arg1 = (wxDC *) 0 ;
14810 int arg2 ;
14811 PyObject * obj0 = 0 ;
14812 PyObject * obj1 = 0 ;
14813 char *kwnames[] = {
14814 (char *) "self",(char *) "mode", NULL
14815 };
14816
14817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
14818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14819 if (SWIG_arg_fail(1)) SWIG_fail;
14820 {
14821 arg2 = (int)(SWIG_As_int(obj1));
14822 if (SWIG_arg_fail(2)) SWIG_fail;
14823 }
14824 {
14825 PyThreadState* __tstate = wxPyBeginAllowThreads();
14826 (arg1)->SetBackgroundMode(arg2);
14827
14828 wxPyEndAllowThreads(__tstate);
14829 if (PyErr_Occurred()) SWIG_fail;
14830 }
14831 Py_INCREF(Py_None); resultobj = Py_None;
14832 return resultobj;
14833 fail:
14834 return NULL;
14835 }
14836
14837
14838 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
14839 PyObject *resultobj;
14840 wxDC *arg1 = (wxDC *) 0 ;
14841 wxPalette *arg2 = 0 ;
14842 PyObject * obj0 = 0 ;
14843 PyObject * obj1 = 0 ;
14844 char *kwnames[] = {
14845 (char *) "self",(char *) "palette", NULL
14846 };
14847
14848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
14849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14850 if (SWIG_arg_fail(1)) SWIG_fail;
14851 {
14852 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
14853 if (SWIG_arg_fail(2)) SWIG_fail;
14854 if (arg2 == NULL) {
14855 SWIG_null_ref("wxPalette");
14856 }
14857 if (SWIG_arg_fail(2)) SWIG_fail;
14858 }
14859 {
14860 PyThreadState* __tstate = wxPyBeginAllowThreads();
14861 (arg1)->SetPalette((wxPalette const &)*arg2);
14862
14863 wxPyEndAllowThreads(__tstate);
14864 if (PyErr_Occurred()) SWIG_fail;
14865 }
14866 Py_INCREF(Py_None); resultobj = Py_None;
14867 return resultobj;
14868 fail:
14869 return NULL;
14870 }
14871
14872
14873 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14874 PyObject *resultobj;
14875 wxDC *arg1 = (wxDC *) 0 ;
14876 PyObject * obj0 = 0 ;
14877 char *kwnames[] = {
14878 (char *) "self", NULL
14879 };
14880
14881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
14882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14883 if (SWIG_arg_fail(1)) SWIG_fail;
14884 {
14885 PyThreadState* __tstate = wxPyBeginAllowThreads();
14886 (arg1)->DestroyClippingRegion();
14887
14888 wxPyEndAllowThreads(__tstate);
14889 if (PyErr_Occurred()) SWIG_fail;
14890 }
14891 Py_INCREF(Py_None); resultobj = Py_None;
14892 return resultobj;
14893 fail:
14894 return NULL;
14895 }
14896
14897
14898 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
14899 PyObject *resultobj;
14900 wxDC *arg1 = (wxDC *) 0 ;
14901 int *arg2 = (int *) 0 ;
14902 int *arg3 = (int *) 0 ;
14903 int *arg4 = (int *) 0 ;
14904 int *arg5 = (int *) 0 ;
14905 int temp2 ;
14906 int res2 = 0 ;
14907 int temp3 ;
14908 int res3 = 0 ;
14909 int temp4 ;
14910 int res4 = 0 ;
14911 int temp5 ;
14912 int res5 = 0 ;
14913 PyObject * obj0 = 0 ;
14914 char *kwnames[] = {
14915 (char *) "self", NULL
14916 };
14917
14918 arg2 = &temp2; res2 = SWIG_NEWOBJ;
14919 arg3 = &temp3; res3 = SWIG_NEWOBJ;
14920 arg4 = &temp4; res4 = SWIG_NEWOBJ;
14921 arg5 = &temp5; res5 = SWIG_NEWOBJ;
14922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
14923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14924 if (SWIG_arg_fail(1)) SWIG_fail;
14925 {
14926 PyThreadState* __tstate = wxPyBeginAllowThreads();
14927 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
14928
14929 wxPyEndAllowThreads(__tstate);
14930 if (PyErr_Occurred()) SWIG_fail;
14931 }
14932 Py_INCREF(Py_None); resultobj = Py_None;
14933 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
14934 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
14935 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
14936 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
14937 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
14938 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
14939 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
14940 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
14941 return resultobj;
14942 fail:
14943 return NULL;
14944 }
14945
14946
14947 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14948 PyObject *resultobj;
14949 wxDC *arg1 = (wxDC *) 0 ;
14950 wxRect result;
14951 PyObject * obj0 = 0 ;
14952 char *kwnames[] = {
14953 (char *) "self", NULL
14954 };
14955
14956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
14957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14958 if (SWIG_arg_fail(1)) SWIG_fail;
14959 {
14960 PyThreadState* __tstate = wxPyBeginAllowThreads();
14961 result = wxDC_GetClippingRect(arg1);
14962
14963 wxPyEndAllowThreads(__tstate);
14964 if (PyErr_Occurred()) SWIG_fail;
14965 }
14966 {
14967 wxRect * resultptr;
14968 resultptr = new wxRect((wxRect &)(result));
14969 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14970 }
14971 return resultobj;
14972 fail:
14973 return NULL;
14974 }
14975
14976
14977 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14978 PyObject *resultobj;
14979 wxDC *arg1 = (wxDC *) 0 ;
14980 int result;
14981 PyObject * obj0 = 0 ;
14982 char *kwnames[] = {
14983 (char *) "self", NULL
14984 };
14985
14986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
14987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14988 if (SWIG_arg_fail(1)) SWIG_fail;
14989 {
14990 PyThreadState* __tstate = wxPyBeginAllowThreads();
14991 result = (int)((wxDC const *)arg1)->GetCharHeight();
14992
14993 wxPyEndAllowThreads(__tstate);
14994 if (PyErr_Occurred()) SWIG_fail;
14995 }
14996 {
14997 resultobj = SWIG_From_int((int)(result));
14998 }
14999 return resultobj;
15000 fail:
15001 return NULL;
15002 }
15003
15004
15005 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
15006 PyObject *resultobj;
15007 wxDC *arg1 = (wxDC *) 0 ;
15008 int result;
15009 PyObject * obj0 = 0 ;
15010 char *kwnames[] = {
15011 (char *) "self", NULL
15012 };
15013
15014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
15015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15016 if (SWIG_arg_fail(1)) SWIG_fail;
15017 {
15018 PyThreadState* __tstate = wxPyBeginAllowThreads();
15019 result = (int)((wxDC const *)arg1)->GetCharWidth();
15020
15021 wxPyEndAllowThreads(__tstate);
15022 if (PyErr_Occurred()) SWIG_fail;
15023 }
15024 {
15025 resultobj = SWIG_From_int((int)(result));
15026 }
15027 return resultobj;
15028 fail:
15029 return NULL;
15030 }
15031
15032
15033 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15034 PyObject *resultobj;
15035 wxDC *arg1 = (wxDC *) 0 ;
15036 wxString *arg2 = 0 ;
15037 int *arg3 = (int *) 0 ;
15038 int *arg4 = (int *) 0 ;
15039 bool temp2 = false ;
15040 int temp3 ;
15041 int res3 = 0 ;
15042 int temp4 ;
15043 int res4 = 0 ;
15044 PyObject * obj0 = 0 ;
15045 PyObject * obj1 = 0 ;
15046 char *kwnames[] = {
15047 (char *) "self",(char *) "string", NULL
15048 };
15049
15050 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15051 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15054 if (SWIG_arg_fail(1)) SWIG_fail;
15055 {
15056 arg2 = wxString_in_helper(obj1);
15057 if (arg2 == NULL) SWIG_fail;
15058 temp2 = true;
15059 }
15060 {
15061 PyThreadState* __tstate = wxPyBeginAllowThreads();
15062 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15063
15064 wxPyEndAllowThreads(__tstate);
15065 if (PyErr_Occurred()) SWIG_fail;
15066 }
15067 Py_INCREF(Py_None); resultobj = Py_None;
15068 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15069 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15070 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15071 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15072 {
15073 if (temp2)
15074 delete arg2;
15075 }
15076 return resultobj;
15077 fail:
15078 {
15079 if (temp2)
15080 delete arg2;
15081 }
15082 return NULL;
15083 }
15084
15085
15086 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15087 PyObject *resultobj;
15088 wxDC *arg1 = (wxDC *) 0 ;
15089 wxString *arg2 = 0 ;
15090 int *arg3 = (int *) 0 ;
15091 int *arg4 = (int *) 0 ;
15092 int *arg5 = (int *) 0 ;
15093 int *arg6 = (int *) 0 ;
15094 wxFont *arg7 = (wxFont *) NULL ;
15095 bool temp2 = false ;
15096 int temp3 ;
15097 int res3 = 0 ;
15098 int temp4 ;
15099 int res4 = 0 ;
15100 int temp5 ;
15101 int res5 = 0 ;
15102 int temp6 ;
15103 int res6 = 0 ;
15104 PyObject * obj0 = 0 ;
15105 PyObject * obj1 = 0 ;
15106 PyObject * obj2 = 0 ;
15107 char *kwnames[] = {
15108 (char *) "self",(char *) "string",(char *) "font", NULL
15109 };
15110
15111 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15112 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15113 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15114 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15117 if (SWIG_arg_fail(1)) SWIG_fail;
15118 {
15119 arg2 = wxString_in_helper(obj1);
15120 if (arg2 == NULL) SWIG_fail;
15121 temp2 = true;
15122 }
15123 if (obj2) {
15124 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15125 if (SWIG_arg_fail(7)) SWIG_fail;
15126 }
15127 {
15128 PyThreadState* __tstate = wxPyBeginAllowThreads();
15129 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15130
15131 wxPyEndAllowThreads(__tstate);
15132 if (PyErr_Occurred()) SWIG_fail;
15133 }
15134 Py_INCREF(Py_None); resultobj = Py_None;
15135 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15136 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15137 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15138 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15139 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15140 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15141 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15142 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15143 {
15144 if (temp2)
15145 delete arg2;
15146 }
15147 return resultobj;
15148 fail:
15149 {
15150 if (temp2)
15151 delete arg2;
15152 }
15153 return NULL;
15154 }
15155
15156
15157 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15158 PyObject *resultobj;
15159 wxDC *arg1 = (wxDC *) 0 ;
15160 wxString *arg2 = 0 ;
15161 int *arg3 = (int *) 0 ;
15162 int *arg4 = (int *) 0 ;
15163 int *arg5 = (int *) 0 ;
15164 wxFont *arg6 = (wxFont *) NULL ;
15165 bool temp2 = false ;
15166 int temp3 ;
15167 int res3 = 0 ;
15168 int temp4 ;
15169 int res4 = 0 ;
15170 int temp5 ;
15171 int res5 = 0 ;
15172 PyObject * obj0 = 0 ;
15173 PyObject * obj1 = 0 ;
15174 PyObject * obj2 = 0 ;
15175 char *kwnames[] = {
15176 (char *) "self",(char *) "text",(char *) "font", NULL
15177 };
15178
15179 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15180 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15181 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15184 if (SWIG_arg_fail(1)) SWIG_fail;
15185 {
15186 arg2 = wxString_in_helper(obj1);
15187 if (arg2 == NULL) SWIG_fail;
15188 temp2 = true;
15189 }
15190 if (obj2) {
15191 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15192 if (SWIG_arg_fail(6)) SWIG_fail;
15193 }
15194 {
15195 PyThreadState* __tstate = wxPyBeginAllowThreads();
15196 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15197
15198 wxPyEndAllowThreads(__tstate);
15199 if (PyErr_Occurred()) SWIG_fail;
15200 }
15201 Py_INCREF(Py_None); resultobj = Py_None;
15202 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15203 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15204 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15205 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15206 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15207 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15208 {
15209 if (temp2)
15210 delete arg2;
15211 }
15212 return resultobj;
15213 fail:
15214 {
15215 if (temp2)
15216 delete arg2;
15217 }
15218 return NULL;
15219 }
15220
15221
15222 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15223 PyObject *resultobj;
15224 wxDC *arg1 = (wxDC *) 0 ;
15225 wxString *arg2 = 0 ;
15226 wxArrayInt result;
15227 bool temp2 = false ;
15228 PyObject * obj0 = 0 ;
15229 PyObject * obj1 = 0 ;
15230 char *kwnames[] = {
15231 (char *) "self",(char *) "text", NULL
15232 };
15233
15234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15236 if (SWIG_arg_fail(1)) SWIG_fail;
15237 {
15238 arg2 = wxString_in_helper(obj1);
15239 if (arg2 == NULL) SWIG_fail;
15240 temp2 = true;
15241 }
15242 {
15243 PyThreadState* __tstate = wxPyBeginAllowThreads();
15244 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15245
15246 wxPyEndAllowThreads(__tstate);
15247 if (PyErr_Occurred()) SWIG_fail;
15248 }
15249 {
15250 resultobj = PyList_New(0);
15251 size_t idx;
15252 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15253 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15254 PyList_Append(resultobj, val);
15255 Py_DECREF(val);
15256 }
15257 }
15258 {
15259 if (temp2)
15260 delete arg2;
15261 }
15262 return resultobj;
15263 fail:
15264 {
15265 if (temp2)
15266 delete arg2;
15267 }
15268 return NULL;
15269 }
15270
15271
15272 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15273 PyObject *resultobj;
15274 wxDC *arg1 = (wxDC *) 0 ;
15275 wxSize result;
15276 PyObject * obj0 = 0 ;
15277 char *kwnames[] = {
15278 (char *) "self", NULL
15279 };
15280
15281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15283 if (SWIG_arg_fail(1)) SWIG_fail;
15284 {
15285 PyThreadState* __tstate = wxPyBeginAllowThreads();
15286 result = (arg1)->GetSize();
15287
15288 wxPyEndAllowThreads(__tstate);
15289 if (PyErr_Occurred()) SWIG_fail;
15290 }
15291 {
15292 wxSize * resultptr;
15293 resultptr = new wxSize((wxSize &)(result));
15294 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15295 }
15296 return resultobj;
15297 fail:
15298 return NULL;
15299 }
15300
15301
15302 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15303 PyObject *resultobj;
15304 wxDC *arg1 = (wxDC *) 0 ;
15305 int *arg2 = (int *) 0 ;
15306 int *arg3 = (int *) 0 ;
15307 int temp2 ;
15308 int res2 = 0 ;
15309 int temp3 ;
15310 int res3 = 0 ;
15311 PyObject * obj0 = 0 ;
15312 char *kwnames[] = {
15313 (char *) "self", NULL
15314 };
15315
15316 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15317 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15320 if (SWIG_arg_fail(1)) SWIG_fail;
15321 {
15322 PyThreadState* __tstate = wxPyBeginAllowThreads();
15323 (arg1)->GetSize(arg2,arg3);
15324
15325 wxPyEndAllowThreads(__tstate);
15326 if (PyErr_Occurred()) SWIG_fail;
15327 }
15328 Py_INCREF(Py_None); resultobj = Py_None;
15329 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15330 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15331 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15332 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15333 return resultobj;
15334 fail:
15335 return NULL;
15336 }
15337
15338
15339 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15340 PyObject *resultobj;
15341 wxDC *arg1 = (wxDC *) 0 ;
15342 wxSize result;
15343 PyObject * obj0 = 0 ;
15344 char *kwnames[] = {
15345 (char *) "self", NULL
15346 };
15347
15348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
15349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15350 if (SWIG_arg_fail(1)) SWIG_fail;
15351 {
15352 PyThreadState* __tstate = wxPyBeginAllowThreads();
15353 result = ((wxDC const *)arg1)->GetSizeMM();
15354
15355 wxPyEndAllowThreads(__tstate);
15356 if (PyErr_Occurred()) SWIG_fail;
15357 }
15358 {
15359 wxSize * resultptr;
15360 resultptr = new wxSize((wxSize &)(result));
15361 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15362 }
15363 return resultobj;
15364 fail:
15365 return NULL;
15366 }
15367
15368
15369 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15370 PyObject *resultobj;
15371 wxDC *arg1 = (wxDC *) 0 ;
15372 int *arg2 = (int *) 0 ;
15373 int *arg3 = (int *) 0 ;
15374 int temp2 ;
15375 int res2 = 0 ;
15376 int temp3 ;
15377 int res3 = 0 ;
15378 PyObject * obj0 = 0 ;
15379 char *kwnames[] = {
15380 (char *) "self", NULL
15381 };
15382
15383 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15384 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
15386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15387 if (SWIG_arg_fail(1)) SWIG_fail;
15388 {
15389 PyThreadState* __tstate = wxPyBeginAllowThreads();
15390 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
15391
15392 wxPyEndAllowThreads(__tstate);
15393 if (PyErr_Occurred()) SWIG_fail;
15394 }
15395 Py_INCREF(Py_None); resultobj = Py_None;
15396 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15397 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15398 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15399 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15400 return resultobj;
15401 fail:
15402 return NULL;
15403 }
15404
15405
15406 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
15407 PyObject *resultobj;
15408 wxDC *arg1 = (wxDC *) 0 ;
15409 int arg2 ;
15410 int result;
15411 PyObject * obj0 = 0 ;
15412 PyObject * obj1 = 0 ;
15413 char *kwnames[] = {
15414 (char *) "self",(char *) "x", NULL
15415 };
15416
15417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
15418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15419 if (SWIG_arg_fail(1)) SWIG_fail;
15420 {
15421 arg2 = (int)(SWIG_As_int(obj1));
15422 if (SWIG_arg_fail(2)) SWIG_fail;
15423 }
15424 {
15425 PyThreadState* __tstate = wxPyBeginAllowThreads();
15426 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
15427
15428 wxPyEndAllowThreads(__tstate);
15429 if (PyErr_Occurred()) SWIG_fail;
15430 }
15431 {
15432 resultobj = SWIG_From_int((int)(result));
15433 }
15434 return resultobj;
15435 fail:
15436 return NULL;
15437 }
15438
15439
15440 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
15441 PyObject *resultobj;
15442 wxDC *arg1 = (wxDC *) 0 ;
15443 int arg2 ;
15444 int result;
15445 PyObject * obj0 = 0 ;
15446 PyObject * obj1 = 0 ;
15447 char *kwnames[] = {
15448 (char *) "self",(char *) "y", NULL
15449 };
15450
15451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
15452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15453 if (SWIG_arg_fail(1)) SWIG_fail;
15454 {
15455 arg2 = (int)(SWIG_As_int(obj1));
15456 if (SWIG_arg_fail(2)) SWIG_fail;
15457 }
15458 {
15459 PyThreadState* __tstate = wxPyBeginAllowThreads();
15460 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
15461
15462 wxPyEndAllowThreads(__tstate);
15463 if (PyErr_Occurred()) SWIG_fail;
15464 }
15465 {
15466 resultobj = SWIG_From_int((int)(result));
15467 }
15468 return resultobj;
15469 fail:
15470 return NULL;
15471 }
15472
15473
15474 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15475 PyObject *resultobj;
15476 wxDC *arg1 = (wxDC *) 0 ;
15477 int arg2 ;
15478 int result;
15479 PyObject * obj0 = 0 ;
15480 PyObject * obj1 = 0 ;
15481 char *kwnames[] = {
15482 (char *) "self",(char *) "x", NULL
15483 };
15484
15485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
15486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15487 if (SWIG_arg_fail(1)) SWIG_fail;
15488 {
15489 arg2 = (int)(SWIG_As_int(obj1));
15490 if (SWIG_arg_fail(2)) SWIG_fail;
15491 }
15492 {
15493 PyThreadState* __tstate = wxPyBeginAllowThreads();
15494 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
15495
15496 wxPyEndAllowThreads(__tstate);
15497 if (PyErr_Occurred()) SWIG_fail;
15498 }
15499 {
15500 resultobj = SWIG_From_int((int)(result));
15501 }
15502 return resultobj;
15503 fail:
15504 return NULL;
15505 }
15506
15507
15508 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15509 PyObject *resultobj;
15510 wxDC *arg1 = (wxDC *) 0 ;
15511 int arg2 ;
15512 int result;
15513 PyObject * obj0 = 0 ;
15514 PyObject * obj1 = 0 ;
15515 char *kwnames[] = {
15516 (char *) "self",(char *) "y", NULL
15517 };
15518
15519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
15520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15521 if (SWIG_arg_fail(1)) SWIG_fail;
15522 {
15523 arg2 = (int)(SWIG_As_int(obj1));
15524 if (SWIG_arg_fail(2)) SWIG_fail;
15525 }
15526 {
15527 PyThreadState* __tstate = wxPyBeginAllowThreads();
15528 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
15529
15530 wxPyEndAllowThreads(__tstate);
15531 if (PyErr_Occurred()) SWIG_fail;
15532 }
15533 {
15534 resultobj = SWIG_From_int((int)(result));
15535 }
15536 return resultobj;
15537 fail:
15538 return NULL;
15539 }
15540
15541
15542 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
15543 PyObject *resultobj;
15544 wxDC *arg1 = (wxDC *) 0 ;
15545 int arg2 ;
15546 int result;
15547 PyObject * obj0 = 0 ;
15548 PyObject * obj1 = 0 ;
15549 char *kwnames[] = {
15550 (char *) "self",(char *) "x", NULL
15551 };
15552
15553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
15554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15555 if (SWIG_arg_fail(1)) SWIG_fail;
15556 {
15557 arg2 = (int)(SWIG_As_int(obj1));
15558 if (SWIG_arg_fail(2)) SWIG_fail;
15559 }
15560 {
15561 PyThreadState* __tstate = wxPyBeginAllowThreads();
15562 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
15563
15564 wxPyEndAllowThreads(__tstate);
15565 if (PyErr_Occurred()) SWIG_fail;
15566 }
15567 {
15568 resultobj = SWIG_From_int((int)(result));
15569 }
15570 return resultobj;
15571 fail:
15572 return NULL;
15573 }
15574
15575
15576 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
15577 PyObject *resultobj;
15578 wxDC *arg1 = (wxDC *) 0 ;
15579 int arg2 ;
15580 int result;
15581 PyObject * obj0 = 0 ;
15582 PyObject * obj1 = 0 ;
15583 char *kwnames[] = {
15584 (char *) "self",(char *) "y", NULL
15585 };
15586
15587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
15588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15589 if (SWIG_arg_fail(1)) SWIG_fail;
15590 {
15591 arg2 = (int)(SWIG_As_int(obj1));
15592 if (SWIG_arg_fail(2)) SWIG_fail;
15593 }
15594 {
15595 PyThreadState* __tstate = wxPyBeginAllowThreads();
15596 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
15597
15598 wxPyEndAllowThreads(__tstate);
15599 if (PyErr_Occurred()) SWIG_fail;
15600 }
15601 {
15602 resultobj = SWIG_From_int((int)(result));
15603 }
15604 return resultobj;
15605 fail:
15606 return NULL;
15607 }
15608
15609
15610 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15611 PyObject *resultobj;
15612 wxDC *arg1 = (wxDC *) 0 ;
15613 int arg2 ;
15614 int result;
15615 PyObject * obj0 = 0 ;
15616 PyObject * obj1 = 0 ;
15617 char *kwnames[] = {
15618 (char *) "self",(char *) "x", NULL
15619 };
15620
15621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
15622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15623 if (SWIG_arg_fail(1)) SWIG_fail;
15624 {
15625 arg2 = (int)(SWIG_As_int(obj1));
15626 if (SWIG_arg_fail(2)) SWIG_fail;
15627 }
15628 {
15629 PyThreadState* __tstate = wxPyBeginAllowThreads();
15630 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
15631
15632 wxPyEndAllowThreads(__tstate);
15633 if (PyErr_Occurred()) SWIG_fail;
15634 }
15635 {
15636 resultobj = SWIG_From_int((int)(result));
15637 }
15638 return resultobj;
15639 fail:
15640 return NULL;
15641 }
15642
15643
15644 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15645 PyObject *resultobj;
15646 wxDC *arg1 = (wxDC *) 0 ;
15647 int arg2 ;
15648 int result;
15649 PyObject * obj0 = 0 ;
15650 PyObject * obj1 = 0 ;
15651 char *kwnames[] = {
15652 (char *) "self",(char *) "y", NULL
15653 };
15654
15655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
15656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15657 if (SWIG_arg_fail(1)) SWIG_fail;
15658 {
15659 arg2 = (int)(SWIG_As_int(obj1));
15660 if (SWIG_arg_fail(2)) SWIG_fail;
15661 }
15662 {
15663 PyThreadState* __tstate = wxPyBeginAllowThreads();
15664 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
15665
15666 wxPyEndAllowThreads(__tstate);
15667 if (PyErr_Occurred()) SWIG_fail;
15668 }
15669 {
15670 resultobj = SWIG_From_int((int)(result));
15671 }
15672 return resultobj;
15673 fail:
15674 return NULL;
15675 }
15676
15677
15678 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
15679 PyObject *resultobj;
15680 wxDC *arg1 = (wxDC *) 0 ;
15681 bool result;
15682 PyObject * obj0 = 0 ;
15683 char *kwnames[] = {
15684 (char *) "self", NULL
15685 };
15686
15687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
15688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15689 if (SWIG_arg_fail(1)) SWIG_fail;
15690 {
15691 PyThreadState* __tstate = wxPyBeginAllowThreads();
15692 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
15693
15694 wxPyEndAllowThreads(__tstate);
15695 if (PyErr_Occurred()) SWIG_fail;
15696 }
15697 {
15698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15699 }
15700 return resultobj;
15701 fail:
15702 return NULL;
15703 }
15704
15705
15706 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15707 PyObject *resultobj;
15708 wxDC *arg1 = (wxDC *) 0 ;
15709 bool result;
15710 PyObject * obj0 = 0 ;
15711 char *kwnames[] = {
15712 (char *) "self", NULL
15713 };
15714
15715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
15716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15717 if (SWIG_arg_fail(1)) SWIG_fail;
15718 {
15719 PyThreadState* __tstate = wxPyBeginAllowThreads();
15720 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
15721
15722 wxPyEndAllowThreads(__tstate);
15723 if (PyErr_Occurred()) SWIG_fail;
15724 }
15725 {
15726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15727 }
15728 return resultobj;
15729 fail:
15730 return NULL;
15731 }
15732
15733
15734 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
15735 PyObject *resultobj;
15736 wxDC *arg1 = (wxDC *) 0 ;
15737 int result;
15738 PyObject * obj0 = 0 ;
15739 char *kwnames[] = {
15740 (char *) "self", NULL
15741 };
15742
15743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
15744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15745 if (SWIG_arg_fail(1)) SWIG_fail;
15746 {
15747 PyThreadState* __tstate = wxPyBeginAllowThreads();
15748 result = (int)((wxDC const *)arg1)->GetDepth();
15749
15750 wxPyEndAllowThreads(__tstate);
15751 if (PyErr_Occurred()) SWIG_fail;
15752 }
15753 {
15754 resultobj = SWIG_From_int((int)(result));
15755 }
15756 return resultobj;
15757 fail:
15758 return NULL;
15759 }
15760
15761
15762 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
15763 PyObject *resultobj;
15764 wxDC *arg1 = (wxDC *) 0 ;
15765 wxSize result;
15766 PyObject * obj0 = 0 ;
15767 char *kwnames[] = {
15768 (char *) "self", NULL
15769 };
15770
15771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
15772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15773 if (SWIG_arg_fail(1)) SWIG_fail;
15774 {
15775 PyThreadState* __tstate = wxPyBeginAllowThreads();
15776 result = ((wxDC const *)arg1)->GetPPI();
15777
15778 wxPyEndAllowThreads(__tstate);
15779 if (PyErr_Occurred()) SWIG_fail;
15780 }
15781 {
15782 wxSize * resultptr;
15783 resultptr = new wxSize((wxSize &)(result));
15784 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15785 }
15786 return resultobj;
15787 fail:
15788 return NULL;
15789 }
15790
15791
15792 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
15793 PyObject *resultobj;
15794 wxDC *arg1 = (wxDC *) 0 ;
15795 bool result;
15796 PyObject * obj0 = 0 ;
15797 char *kwnames[] = {
15798 (char *) "self", NULL
15799 };
15800
15801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
15802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15803 if (SWIG_arg_fail(1)) SWIG_fail;
15804 {
15805 PyThreadState* __tstate = wxPyBeginAllowThreads();
15806 result = (bool)((wxDC const *)arg1)->Ok();
15807
15808 wxPyEndAllowThreads(__tstate);
15809 if (PyErr_Occurred()) SWIG_fail;
15810 }
15811 {
15812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15813 }
15814 return resultobj;
15815 fail:
15816 return NULL;
15817 }
15818
15819
15820 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15821 PyObject *resultobj;
15822 wxDC *arg1 = (wxDC *) 0 ;
15823 int result;
15824 PyObject * obj0 = 0 ;
15825 char *kwnames[] = {
15826 (char *) "self", NULL
15827 };
15828
15829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
15830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15831 if (SWIG_arg_fail(1)) SWIG_fail;
15832 {
15833 PyThreadState* __tstate = wxPyBeginAllowThreads();
15834 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
15835
15836 wxPyEndAllowThreads(__tstate);
15837 if (PyErr_Occurred()) SWIG_fail;
15838 }
15839 {
15840 resultobj = SWIG_From_int((int)(result));
15841 }
15842 return resultobj;
15843 fail:
15844 return NULL;
15845 }
15846
15847
15848 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15849 PyObject *resultobj;
15850 wxDC *arg1 = (wxDC *) 0 ;
15851 wxBrush *result;
15852 PyObject * obj0 = 0 ;
15853 char *kwnames[] = {
15854 (char *) "self", NULL
15855 };
15856
15857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
15858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15859 if (SWIG_arg_fail(1)) SWIG_fail;
15860 {
15861 PyThreadState* __tstate = wxPyBeginAllowThreads();
15862 {
15863 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
15864 result = (wxBrush *) &_result_ref;
15865 }
15866
15867 wxPyEndAllowThreads(__tstate);
15868 if (PyErr_Occurred()) SWIG_fail;
15869 }
15870 {
15871 wxBrush* resultptr = new wxBrush(*result);
15872 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15873 }
15874 return resultobj;
15875 fail:
15876 return NULL;
15877 }
15878
15879
15880 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15881 PyObject *resultobj;
15882 wxDC *arg1 = (wxDC *) 0 ;
15883 wxBrush *result;
15884 PyObject * obj0 = 0 ;
15885 char *kwnames[] = {
15886 (char *) "self", NULL
15887 };
15888
15889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
15890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15891 if (SWIG_arg_fail(1)) SWIG_fail;
15892 {
15893 PyThreadState* __tstate = wxPyBeginAllowThreads();
15894 {
15895 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
15896 result = (wxBrush *) &_result_ref;
15897 }
15898
15899 wxPyEndAllowThreads(__tstate);
15900 if (PyErr_Occurred()) SWIG_fail;
15901 }
15902 {
15903 wxBrush* resultptr = new wxBrush(*result);
15904 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15905 }
15906 return resultobj;
15907 fail:
15908 return NULL;
15909 }
15910
15911
15912 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15913 PyObject *resultobj;
15914 wxDC *arg1 = (wxDC *) 0 ;
15915 wxFont *result;
15916 PyObject * obj0 = 0 ;
15917 char *kwnames[] = {
15918 (char *) "self", NULL
15919 };
15920
15921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
15922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15923 if (SWIG_arg_fail(1)) SWIG_fail;
15924 {
15925 PyThreadState* __tstate = wxPyBeginAllowThreads();
15926 {
15927 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
15928 result = (wxFont *) &_result_ref;
15929 }
15930
15931 wxPyEndAllowThreads(__tstate);
15932 if (PyErr_Occurred()) SWIG_fail;
15933 }
15934 {
15935 wxFont* resultptr = new wxFont(*result);
15936 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
15937 }
15938 return resultobj;
15939 fail:
15940 return NULL;
15941 }
15942
15943
15944 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
15945 PyObject *resultobj;
15946 wxDC *arg1 = (wxDC *) 0 ;
15947 wxPen *result;
15948 PyObject * obj0 = 0 ;
15949 char *kwnames[] = {
15950 (char *) "self", NULL
15951 };
15952
15953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
15954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15955 if (SWIG_arg_fail(1)) SWIG_fail;
15956 {
15957 PyThreadState* __tstate = wxPyBeginAllowThreads();
15958 {
15959 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
15960 result = (wxPen *) &_result_ref;
15961 }
15962
15963 wxPyEndAllowThreads(__tstate);
15964 if (PyErr_Occurred()) SWIG_fail;
15965 }
15966 {
15967 wxPen* resultptr = new wxPen(*result);
15968 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
15969 }
15970 return resultobj;
15971 fail:
15972 return NULL;
15973 }
15974
15975
15976 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15977 PyObject *resultobj;
15978 wxDC *arg1 = (wxDC *) 0 ;
15979 wxColour *result;
15980 PyObject * obj0 = 0 ;
15981 char *kwnames[] = {
15982 (char *) "self", NULL
15983 };
15984
15985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
15986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15987 if (SWIG_arg_fail(1)) SWIG_fail;
15988 {
15989 PyThreadState* __tstate = wxPyBeginAllowThreads();
15990 {
15991 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
15992 result = (wxColour *) &_result_ref;
15993 }
15994
15995 wxPyEndAllowThreads(__tstate);
15996 if (PyErr_Occurred()) SWIG_fail;
15997 }
15998 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
15999 return resultobj;
16000 fail:
16001 return NULL;
16002 }
16003
16004
16005 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16006 PyObject *resultobj;
16007 wxDC *arg1 = (wxDC *) 0 ;
16008 wxColour *result;
16009 PyObject * obj0 = 0 ;
16010 char *kwnames[] = {
16011 (char *) "self", NULL
16012 };
16013
16014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
16015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16016 if (SWIG_arg_fail(1)) SWIG_fail;
16017 {
16018 PyThreadState* __tstate = wxPyBeginAllowThreads();
16019 {
16020 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
16021 result = (wxColour *) &_result_ref;
16022 }
16023
16024 wxPyEndAllowThreads(__tstate);
16025 if (PyErr_Occurred()) SWIG_fail;
16026 }
16027 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16028 return resultobj;
16029 fail:
16030 return NULL;
16031 }
16032
16033
16034 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16035 PyObject *resultobj;
16036 wxDC *arg1 = (wxDC *) 0 ;
16037 wxColour *arg2 = 0 ;
16038 wxColour temp2 ;
16039 PyObject * obj0 = 0 ;
16040 PyObject * obj1 = 0 ;
16041 char *kwnames[] = {
16042 (char *) "self",(char *) "colour", NULL
16043 };
16044
16045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16047 if (SWIG_arg_fail(1)) SWIG_fail;
16048 {
16049 arg2 = &temp2;
16050 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16051 }
16052 {
16053 PyThreadState* __tstate = wxPyBeginAllowThreads();
16054 (arg1)->SetTextForeground((wxColour const &)*arg2);
16055
16056 wxPyEndAllowThreads(__tstate);
16057 if (PyErr_Occurred()) SWIG_fail;
16058 }
16059 Py_INCREF(Py_None); resultobj = Py_None;
16060 return resultobj;
16061 fail:
16062 return NULL;
16063 }
16064
16065
16066 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16067 PyObject *resultobj;
16068 wxDC *arg1 = (wxDC *) 0 ;
16069 wxColour *arg2 = 0 ;
16070 wxColour temp2 ;
16071 PyObject * obj0 = 0 ;
16072 PyObject * obj1 = 0 ;
16073 char *kwnames[] = {
16074 (char *) "self",(char *) "colour", NULL
16075 };
16076
16077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16079 if (SWIG_arg_fail(1)) SWIG_fail;
16080 {
16081 arg2 = &temp2;
16082 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16083 }
16084 {
16085 PyThreadState* __tstate = wxPyBeginAllowThreads();
16086 (arg1)->SetTextBackground((wxColour const &)*arg2);
16087
16088 wxPyEndAllowThreads(__tstate);
16089 if (PyErr_Occurred()) SWIG_fail;
16090 }
16091 Py_INCREF(Py_None); resultobj = Py_None;
16092 return resultobj;
16093 fail:
16094 return NULL;
16095 }
16096
16097
16098 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16099 PyObject *resultobj;
16100 wxDC *arg1 = (wxDC *) 0 ;
16101 int result;
16102 PyObject * obj0 = 0 ;
16103 char *kwnames[] = {
16104 (char *) "self", NULL
16105 };
16106
16107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16109 if (SWIG_arg_fail(1)) SWIG_fail;
16110 {
16111 PyThreadState* __tstate = wxPyBeginAllowThreads();
16112 result = (int)((wxDC const *)arg1)->GetMapMode();
16113
16114 wxPyEndAllowThreads(__tstate);
16115 if (PyErr_Occurred()) SWIG_fail;
16116 }
16117 {
16118 resultobj = SWIG_From_int((int)(result));
16119 }
16120 return resultobj;
16121 fail:
16122 return NULL;
16123 }
16124
16125
16126 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16127 PyObject *resultobj;
16128 wxDC *arg1 = (wxDC *) 0 ;
16129 int arg2 ;
16130 PyObject * obj0 = 0 ;
16131 PyObject * obj1 = 0 ;
16132 char *kwnames[] = {
16133 (char *) "self",(char *) "mode", NULL
16134 };
16135
16136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16138 if (SWIG_arg_fail(1)) SWIG_fail;
16139 {
16140 arg2 = (int)(SWIG_As_int(obj1));
16141 if (SWIG_arg_fail(2)) SWIG_fail;
16142 }
16143 {
16144 PyThreadState* __tstate = wxPyBeginAllowThreads();
16145 (arg1)->SetMapMode(arg2);
16146
16147 wxPyEndAllowThreads(__tstate);
16148 if (PyErr_Occurred()) SWIG_fail;
16149 }
16150 Py_INCREF(Py_None); resultobj = Py_None;
16151 return resultobj;
16152 fail:
16153 return NULL;
16154 }
16155
16156
16157 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16158 PyObject *resultobj;
16159 wxDC *arg1 = (wxDC *) 0 ;
16160 double *arg2 = (double *) 0 ;
16161 double *arg3 = (double *) 0 ;
16162 double temp2 ;
16163 int res2 = 0 ;
16164 double temp3 ;
16165 int res3 = 0 ;
16166 PyObject * obj0 = 0 ;
16167 char *kwnames[] = {
16168 (char *) "self", NULL
16169 };
16170
16171 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16172 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16175 if (SWIG_arg_fail(1)) SWIG_fail;
16176 {
16177 PyThreadState* __tstate = wxPyBeginAllowThreads();
16178 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16179
16180 wxPyEndAllowThreads(__tstate);
16181 if (PyErr_Occurred()) SWIG_fail;
16182 }
16183 Py_INCREF(Py_None); resultobj = Py_None;
16184 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16185 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16186 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16187 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16188 return resultobj;
16189 fail:
16190 return NULL;
16191 }
16192
16193
16194 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16195 PyObject *resultobj;
16196 wxDC *arg1 = (wxDC *) 0 ;
16197 double arg2 ;
16198 double arg3 ;
16199 PyObject * obj0 = 0 ;
16200 PyObject * obj1 = 0 ;
16201 PyObject * obj2 = 0 ;
16202 char *kwnames[] = {
16203 (char *) "self",(char *) "x",(char *) "y", NULL
16204 };
16205
16206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16208 if (SWIG_arg_fail(1)) SWIG_fail;
16209 {
16210 arg2 = (double)(SWIG_As_double(obj1));
16211 if (SWIG_arg_fail(2)) SWIG_fail;
16212 }
16213 {
16214 arg3 = (double)(SWIG_As_double(obj2));
16215 if (SWIG_arg_fail(3)) SWIG_fail;
16216 }
16217 {
16218 PyThreadState* __tstate = wxPyBeginAllowThreads();
16219 (arg1)->SetUserScale(arg2,arg3);
16220
16221 wxPyEndAllowThreads(__tstate);
16222 if (PyErr_Occurred()) SWIG_fail;
16223 }
16224 Py_INCREF(Py_None); resultobj = Py_None;
16225 return resultobj;
16226 fail:
16227 return NULL;
16228 }
16229
16230
16231 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16232 PyObject *resultobj;
16233 wxDC *arg1 = (wxDC *) 0 ;
16234 double *arg2 = (double *) 0 ;
16235 double *arg3 = (double *) 0 ;
16236 double temp2 ;
16237 int res2 = 0 ;
16238 double temp3 ;
16239 int res3 = 0 ;
16240 PyObject * obj0 = 0 ;
16241 char *kwnames[] = {
16242 (char *) "self", NULL
16243 };
16244
16245 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16246 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16249 if (SWIG_arg_fail(1)) SWIG_fail;
16250 {
16251 PyThreadState* __tstate = wxPyBeginAllowThreads();
16252 (arg1)->GetLogicalScale(arg2,arg3);
16253
16254 wxPyEndAllowThreads(__tstate);
16255 if (PyErr_Occurred()) SWIG_fail;
16256 }
16257 Py_INCREF(Py_None); resultobj = Py_None;
16258 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16259 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16260 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16261 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16262 return resultobj;
16263 fail:
16264 return NULL;
16265 }
16266
16267
16268 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16269 PyObject *resultobj;
16270 wxDC *arg1 = (wxDC *) 0 ;
16271 double arg2 ;
16272 double arg3 ;
16273 PyObject * obj0 = 0 ;
16274 PyObject * obj1 = 0 ;
16275 PyObject * obj2 = 0 ;
16276 char *kwnames[] = {
16277 (char *) "self",(char *) "x",(char *) "y", NULL
16278 };
16279
16280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16282 if (SWIG_arg_fail(1)) SWIG_fail;
16283 {
16284 arg2 = (double)(SWIG_As_double(obj1));
16285 if (SWIG_arg_fail(2)) SWIG_fail;
16286 }
16287 {
16288 arg3 = (double)(SWIG_As_double(obj2));
16289 if (SWIG_arg_fail(3)) SWIG_fail;
16290 }
16291 {
16292 PyThreadState* __tstate = wxPyBeginAllowThreads();
16293 (arg1)->SetLogicalScale(arg2,arg3);
16294
16295 wxPyEndAllowThreads(__tstate);
16296 if (PyErr_Occurred()) SWIG_fail;
16297 }
16298 Py_INCREF(Py_None); resultobj = Py_None;
16299 return resultobj;
16300 fail:
16301 return NULL;
16302 }
16303
16304
16305 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16306 PyObject *resultobj;
16307 wxDC *arg1 = (wxDC *) 0 ;
16308 wxPoint result;
16309 PyObject * obj0 = 0 ;
16310 char *kwnames[] = {
16311 (char *) "self", NULL
16312 };
16313
16314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16316 if (SWIG_arg_fail(1)) SWIG_fail;
16317 {
16318 PyThreadState* __tstate = wxPyBeginAllowThreads();
16319 result = ((wxDC const *)arg1)->GetLogicalOrigin();
16320
16321 wxPyEndAllowThreads(__tstate);
16322 if (PyErr_Occurred()) SWIG_fail;
16323 }
16324 {
16325 wxPoint * resultptr;
16326 resultptr = new wxPoint((wxPoint &)(result));
16327 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16328 }
16329 return resultobj;
16330 fail:
16331 return NULL;
16332 }
16333
16334
16335 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16336 PyObject *resultobj;
16337 wxDC *arg1 = (wxDC *) 0 ;
16338 int *arg2 = (int *) 0 ;
16339 int *arg3 = (int *) 0 ;
16340 int temp2 ;
16341 int res2 = 0 ;
16342 int temp3 ;
16343 int res3 = 0 ;
16344 PyObject * obj0 = 0 ;
16345 char *kwnames[] = {
16346 (char *) "self", NULL
16347 };
16348
16349 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16350 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
16352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16353 if (SWIG_arg_fail(1)) SWIG_fail;
16354 {
16355 PyThreadState* __tstate = wxPyBeginAllowThreads();
16356 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
16357
16358 wxPyEndAllowThreads(__tstate);
16359 if (PyErr_Occurred()) SWIG_fail;
16360 }
16361 Py_INCREF(Py_None); resultobj = Py_None;
16362 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16363 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16364 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16365 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16366 return resultobj;
16367 fail:
16368 return NULL;
16369 }
16370
16371
16372 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16373 PyObject *resultobj;
16374 wxDC *arg1 = (wxDC *) 0 ;
16375 int arg2 ;
16376 int arg3 ;
16377 PyObject * obj0 = 0 ;
16378 PyObject * obj1 = 0 ;
16379 PyObject * obj2 = 0 ;
16380 char *kwnames[] = {
16381 (char *) "self",(char *) "x",(char *) "y", NULL
16382 };
16383
16384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16386 if (SWIG_arg_fail(1)) SWIG_fail;
16387 {
16388 arg2 = (int)(SWIG_As_int(obj1));
16389 if (SWIG_arg_fail(2)) SWIG_fail;
16390 }
16391 {
16392 arg3 = (int)(SWIG_As_int(obj2));
16393 if (SWIG_arg_fail(3)) SWIG_fail;
16394 }
16395 {
16396 PyThreadState* __tstate = wxPyBeginAllowThreads();
16397 (arg1)->SetLogicalOrigin(arg2,arg3);
16398
16399 wxPyEndAllowThreads(__tstate);
16400 if (PyErr_Occurred()) SWIG_fail;
16401 }
16402 Py_INCREF(Py_None); resultobj = Py_None;
16403 return resultobj;
16404 fail:
16405 return NULL;
16406 }
16407
16408
16409 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16410 PyObject *resultobj;
16411 wxDC *arg1 = (wxDC *) 0 ;
16412 wxPoint *arg2 = 0 ;
16413 wxPoint temp2 ;
16414 PyObject * obj0 = 0 ;
16415 PyObject * obj1 = 0 ;
16416 char *kwnames[] = {
16417 (char *) "self",(char *) "point", NULL
16418 };
16419
16420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16422 if (SWIG_arg_fail(1)) SWIG_fail;
16423 {
16424 arg2 = &temp2;
16425 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16426 }
16427 {
16428 PyThreadState* __tstate = wxPyBeginAllowThreads();
16429 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
16430
16431 wxPyEndAllowThreads(__tstate);
16432 if (PyErr_Occurred()) SWIG_fail;
16433 }
16434 Py_INCREF(Py_None); resultobj = Py_None;
16435 return resultobj;
16436 fail:
16437 return NULL;
16438 }
16439
16440
16441 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16442 PyObject *resultobj;
16443 wxDC *arg1 = (wxDC *) 0 ;
16444 wxPoint result;
16445 PyObject * obj0 = 0 ;
16446 char *kwnames[] = {
16447 (char *) "self", NULL
16448 };
16449
16450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
16451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16452 if (SWIG_arg_fail(1)) SWIG_fail;
16453 {
16454 PyThreadState* __tstate = wxPyBeginAllowThreads();
16455 result = ((wxDC const *)arg1)->GetDeviceOrigin();
16456
16457 wxPyEndAllowThreads(__tstate);
16458 if (PyErr_Occurred()) SWIG_fail;
16459 }
16460 {
16461 wxPoint * resultptr;
16462 resultptr = new wxPoint((wxPoint &)(result));
16463 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16464 }
16465 return resultobj;
16466 fail:
16467 return NULL;
16468 }
16469
16470
16471 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16472 PyObject *resultobj;
16473 wxDC *arg1 = (wxDC *) 0 ;
16474 int *arg2 = (int *) 0 ;
16475 int *arg3 = (int *) 0 ;
16476 int temp2 ;
16477 int res2 = 0 ;
16478 int temp3 ;
16479 int res3 = 0 ;
16480 PyObject * obj0 = 0 ;
16481 char *kwnames[] = {
16482 (char *) "self", NULL
16483 };
16484
16485 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16486 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
16488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16489 if (SWIG_arg_fail(1)) SWIG_fail;
16490 {
16491 PyThreadState* __tstate = wxPyBeginAllowThreads();
16492 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
16493
16494 wxPyEndAllowThreads(__tstate);
16495 if (PyErr_Occurred()) SWIG_fail;
16496 }
16497 Py_INCREF(Py_None); resultobj = Py_None;
16498 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16499 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16500 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16501 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16502 return resultobj;
16503 fail:
16504 return NULL;
16505 }
16506
16507
16508 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16509 PyObject *resultobj;
16510 wxDC *arg1 = (wxDC *) 0 ;
16511 int arg2 ;
16512 int arg3 ;
16513 PyObject * obj0 = 0 ;
16514 PyObject * obj1 = 0 ;
16515 PyObject * obj2 = 0 ;
16516 char *kwnames[] = {
16517 (char *) "self",(char *) "x",(char *) "y", NULL
16518 };
16519
16520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16522 if (SWIG_arg_fail(1)) SWIG_fail;
16523 {
16524 arg2 = (int)(SWIG_As_int(obj1));
16525 if (SWIG_arg_fail(2)) SWIG_fail;
16526 }
16527 {
16528 arg3 = (int)(SWIG_As_int(obj2));
16529 if (SWIG_arg_fail(3)) SWIG_fail;
16530 }
16531 {
16532 PyThreadState* __tstate = wxPyBeginAllowThreads();
16533 (arg1)->SetDeviceOrigin(arg2,arg3);
16534
16535 wxPyEndAllowThreads(__tstate);
16536 if (PyErr_Occurred()) SWIG_fail;
16537 }
16538 Py_INCREF(Py_None); resultobj = Py_None;
16539 return resultobj;
16540 fail:
16541 return NULL;
16542 }
16543
16544
16545 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16546 PyObject *resultobj;
16547 wxDC *arg1 = (wxDC *) 0 ;
16548 wxPoint *arg2 = 0 ;
16549 wxPoint temp2 ;
16550 PyObject * obj0 = 0 ;
16551 PyObject * obj1 = 0 ;
16552 char *kwnames[] = {
16553 (char *) "self",(char *) "point", NULL
16554 };
16555
16556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16558 if (SWIG_arg_fail(1)) SWIG_fail;
16559 {
16560 arg2 = &temp2;
16561 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16562 }
16563 {
16564 PyThreadState* __tstate = wxPyBeginAllowThreads();
16565 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
16566
16567 wxPyEndAllowThreads(__tstate);
16568 if (PyErr_Occurred()) SWIG_fail;
16569 }
16570 Py_INCREF(Py_None); resultobj = Py_None;
16571 return resultobj;
16572 fail:
16573 return NULL;
16574 }
16575
16576
16577 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16578 PyObject *resultobj;
16579 wxDC *arg1 = (wxDC *) 0 ;
16580 bool arg2 ;
16581 bool arg3 ;
16582 PyObject * obj0 = 0 ;
16583 PyObject * obj1 = 0 ;
16584 PyObject * obj2 = 0 ;
16585 char *kwnames[] = {
16586 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
16587 };
16588
16589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
16590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16591 if (SWIG_arg_fail(1)) SWIG_fail;
16592 {
16593 arg2 = (bool)(SWIG_As_bool(obj1));
16594 if (SWIG_arg_fail(2)) SWIG_fail;
16595 }
16596 {
16597 arg3 = (bool)(SWIG_As_bool(obj2));
16598 if (SWIG_arg_fail(3)) SWIG_fail;
16599 }
16600 {
16601 PyThreadState* __tstate = wxPyBeginAllowThreads();
16602 (arg1)->SetAxisOrientation(arg2,arg3);
16603
16604 wxPyEndAllowThreads(__tstate);
16605 if (PyErr_Occurred()) SWIG_fail;
16606 }
16607 Py_INCREF(Py_None); resultobj = Py_None;
16608 return resultobj;
16609 fail:
16610 return NULL;
16611 }
16612
16613
16614 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16615 PyObject *resultobj;
16616 wxDC *arg1 = (wxDC *) 0 ;
16617 int result;
16618 PyObject * obj0 = 0 ;
16619 char *kwnames[] = {
16620 (char *) "self", NULL
16621 };
16622
16623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
16624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16625 if (SWIG_arg_fail(1)) SWIG_fail;
16626 {
16627 PyThreadState* __tstate = wxPyBeginAllowThreads();
16628 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
16629
16630 wxPyEndAllowThreads(__tstate);
16631 if (PyErr_Occurred()) SWIG_fail;
16632 }
16633 {
16634 resultobj = SWIG_From_int((int)(result));
16635 }
16636 return resultobj;
16637 fail:
16638 return NULL;
16639 }
16640
16641
16642 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16643 PyObject *resultobj;
16644 wxDC *arg1 = (wxDC *) 0 ;
16645 int arg2 ;
16646 PyObject * obj0 = 0 ;
16647 PyObject * obj1 = 0 ;
16648 char *kwnames[] = {
16649 (char *) "self",(char *) "function", NULL
16650 };
16651
16652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
16653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16654 if (SWIG_arg_fail(1)) SWIG_fail;
16655 {
16656 arg2 = (int)(SWIG_As_int(obj1));
16657 if (SWIG_arg_fail(2)) SWIG_fail;
16658 }
16659 {
16660 PyThreadState* __tstate = wxPyBeginAllowThreads();
16661 (arg1)->SetLogicalFunction(arg2);
16662
16663 wxPyEndAllowThreads(__tstate);
16664 if (PyErr_Occurred()) SWIG_fail;
16665 }
16666 Py_INCREF(Py_None); resultobj = Py_None;
16667 return resultobj;
16668 fail:
16669 return NULL;
16670 }
16671
16672
16673 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16674 PyObject *resultobj;
16675 wxDC *arg1 = (wxDC *) 0 ;
16676 PyObject * obj0 = 0 ;
16677 char *kwnames[] = {
16678 (char *) "self", NULL
16679 };
16680
16681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
16682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16683 if (SWIG_arg_fail(1)) SWIG_fail;
16684 {
16685 PyThreadState* __tstate = wxPyBeginAllowThreads();
16686 (arg1)->ComputeScaleAndOrigin();
16687
16688 wxPyEndAllowThreads(__tstate);
16689 if (PyErr_Occurred()) SWIG_fail;
16690 }
16691 Py_INCREF(Py_None); resultobj = Py_None;
16692 return resultobj;
16693 fail:
16694 return NULL;
16695 }
16696
16697
16698 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16699 PyObject *resultobj;
16700 wxDC *arg1 = (wxDC *) 0 ;
16701 int arg2 ;
16702 int arg3 ;
16703 PyObject * obj0 = 0 ;
16704 PyObject * obj1 = 0 ;
16705 PyObject * obj2 = 0 ;
16706 char *kwnames[] = {
16707 (char *) "self",(char *) "x",(char *) "y", NULL
16708 };
16709
16710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
16711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16712 if (SWIG_arg_fail(1)) SWIG_fail;
16713 {
16714 arg2 = (int)(SWIG_As_int(obj1));
16715 if (SWIG_arg_fail(2)) SWIG_fail;
16716 }
16717 {
16718 arg3 = (int)(SWIG_As_int(obj2));
16719 if (SWIG_arg_fail(3)) SWIG_fail;
16720 }
16721 {
16722 PyThreadState* __tstate = wxPyBeginAllowThreads();
16723 (arg1)->CalcBoundingBox(arg2,arg3);
16724
16725 wxPyEndAllowThreads(__tstate);
16726 if (PyErr_Occurred()) SWIG_fail;
16727 }
16728 Py_INCREF(Py_None); resultobj = Py_None;
16729 return resultobj;
16730 fail:
16731 return NULL;
16732 }
16733
16734
16735 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16736 PyObject *resultobj;
16737 wxDC *arg1 = (wxDC *) 0 ;
16738 wxPoint *arg2 = 0 ;
16739 wxPoint temp2 ;
16740 PyObject * obj0 = 0 ;
16741 PyObject * obj1 = 0 ;
16742 char *kwnames[] = {
16743 (char *) "self",(char *) "point", NULL
16744 };
16745
16746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
16747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16748 if (SWIG_arg_fail(1)) SWIG_fail;
16749 {
16750 arg2 = &temp2;
16751 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16752 }
16753 {
16754 PyThreadState* __tstate = wxPyBeginAllowThreads();
16755 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
16756
16757 wxPyEndAllowThreads(__tstate);
16758 if (PyErr_Occurred()) SWIG_fail;
16759 }
16760 Py_INCREF(Py_None); resultobj = Py_None;
16761 return resultobj;
16762 fail:
16763 return NULL;
16764 }
16765
16766
16767 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16768 PyObject *resultobj;
16769 wxDC *arg1 = (wxDC *) 0 ;
16770 PyObject * obj0 = 0 ;
16771 char *kwnames[] = {
16772 (char *) "self", NULL
16773 };
16774
16775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
16776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16777 if (SWIG_arg_fail(1)) SWIG_fail;
16778 {
16779 PyThreadState* __tstate = wxPyBeginAllowThreads();
16780 (arg1)->ResetBoundingBox();
16781
16782 wxPyEndAllowThreads(__tstate);
16783 if (PyErr_Occurred()) SWIG_fail;
16784 }
16785 Py_INCREF(Py_None); resultobj = Py_None;
16786 return resultobj;
16787 fail:
16788 return NULL;
16789 }
16790
16791
16792 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
16793 PyObject *resultobj;
16794 wxDC *arg1 = (wxDC *) 0 ;
16795 int result;
16796 PyObject * obj0 = 0 ;
16797 char *kwnames[] = {
16798 (char *) "self", NULL
16799 };
16800
16801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
16802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16803 if (SWIG_arg_fail(1)) SWIG_fail;
16804 {
16805 PyThreadState* __tstate = wxPyBeginAllowThreads();
16806 result = (int)((wxDC const *)arg1)->MinX();
16807
16808 wxPyEndAllowThreads(__tstate);
16809 if (PyErr_Occurred()) SWIG_fail;
16810 }
16811 {
16812 resultobj = SWIG_From_int((int)(result));
16813 }
16814 return resultobj;
16815 fail:
16816 return NULL;
16817 }
16818
16819
16820 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
16821 PyObject *resultobj;
16822 wxDC *arg1 = (wxDC *) 0 ;
16823 int result;
16824 PyObject * obj0 = 0 ;
16825 char *kwnames[] = {
16826 (char *) "self", NULL
16827 };
16828
16829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
16830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16831 if (SWIG_arg_fail(1)) SWIG_fail;
16832 {
16833 PyThreadState* __tstate = wxPyBeginAllowThreads();
16834 result = (int)((wxDC const *)arg1)->MaxX();
16835
16836 wxPyEndAllowThreads(__tstate);
16837 if (PyErr_Occurred()) SWIG_fail;
16838 }
16839 {
16840 resultobj = SWIG_From_int((int)(result));
16841 }
16842 return resultobj;
16843 fail:
16844 return NULL;
16845 }
16846
16847
16848 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
16849 PyObject *resultobj;
16850 wxDC *arg1 = (wxDC *) 0 ;
16851 int result;
16852 PyObject * obj0 = 0 ;
16853 char *kwnames[] = {
16854 (char *) "self", NULL
16855 };
16856
16857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
16858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16859 if (SWIG_arg_fail(1)) SWIG_fail;
16860 {
16861 PyThreadState* __tstate = wxPyBeginAllowThreads();
16862 result = (int)((wxDC const *)arg1)->MinY();
16863
16864 wxPyEndAllowThreads(__tstate);
16865 if (PyErr_Occurred()) SWIG_fail;
16866 }
16867 {
16868 resultobj = SWIG_From_int((int)(result));
16869 }
16870 return resultobj;
16871 fail:
16872 return NULL;
16873 }
16874
16875
16876 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
16877 PyObject *resultobj;
16878 wxDC *arg1 = (wxDC *) 0 ;
16879 int result;
16880 PyObject * obj0 = 0 ;
16881 char *kwnames[] = {
16882 (char *) "self", NULL
16883 };
16884
16885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
16886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16887 if (SWIG_arg_fail(1)) SWIG_fail;
16888 {
16889 PyThreadState* __tstate = wxPyBeginAllowThreads();
16890 result = (int)((wxDC const *)arg1)->MaxY();
16891
16892 wxPyEndAllowThreads(__tstate);
16893 if (PyErr_Occurred()) SWIG_fail;
16894 }
16895 {
16896 resultobj = SWIG_From_int((int)(result));
16897 }
16898 return resultobj;
16899 fail:
16900 return NULL;
16901 }
16902
16903
16904 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16905 PyObject *resultobj;
16906 wxDC *arg1 = (wxDC *) 0 ;
16907 int *arg2 = (int *) 0 ;
16908 int *arg3 = (int *) 0 ;
16909 int *arg4 = (int *) 0 ;
16910 int *arg5 = (int *) 0 ;
16911 int temp2 ;
16912 int res2 = 0 ;
16913 int temp3 ;
16914 int res3 = 0 ;
16915 int temp4 ;
16916 int res4 = 0 ;
16917 int temp5 ;
16918 int res5 = 0 ;
16919 PyObject * obj0 = 0 ;
16920 char *kwnames[] = {
16921 (char *) "self", NULL
16922 };
16923
16924 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16925 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16926 arg4 = &temp4; res4 = SWIG_NEWOBJ;
16927 arg5 = &temp5; res5 = SWIG_NEWOBJ;
16928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
16929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16930 if (SWIG_arg_fail(1)) SWIG_fail;
16931 {
16932 PyThreadState* __tstate = wxPyBeginAllowThreads();
16933 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
16934
16935 wxPyEndAllowThreads(__tstate);
16936 if (PyErr_Occurred()) SWIG_fail;
16937 }
16938 Py_INCREF(Py_None); resultobj = Py_None;
16939 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16940 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16941 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16942 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16943 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
16944 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
16945 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
16946 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
16947 return resultobj;
16948 fail:
16949 return NULL;
16950 }
16951
16952
16953 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
16954 PyObject *resultobj;
16955 wxDC *arg1 = (wxDC *) 0 ;
16956 PyObject *arg2 = (PyObject *) 0 ;
16957 PyObject *arg3 = (PyObject *) 0 ;
16958 PyObject *arg4 = (PyObject *) 0 ;
16959 PyObject *result;
16960 PyObject * obj0 = 0 ;
16961 PyObject * obj1 = 0 ;
16962 PyObject * obj2 = 0 ;
16963 PyObject * obj3 = 0 ;
16964 char *kwnames[] = {
16965 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16966 };
16967
16968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16970 if (SWIG_arg_fail(1)) SWIG_fail;
16971 arg2 = obj1;
16972 arg3 = obj2;
16973 arg4 = obj3;
16974 {
16975 PyThreadState* __tstate = wxPyBeginAllowThreads();
16976 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
16977
16978 wxPyEndAllowThreads(__tstate);
16979 if (PyErr_Occurred()) SWIG_fail;
16980 }
16981 resultobj = result;
16982 return resultobj;
16983 fail:
16984 return NULL;
16985 }
16986
16987
16988 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
16989 PyObject *resultobj;
16990 wxDC *arg1 = (wxDC *) 0 ;
16991 PyObject *arg2 = (PyObject *) 0 ;
16992 PyObject *arg3 = (PyObject *) 0 ;
16993 PyObject *arg4 = (PyObject *) 0 ;
16994 PyObject *result;
16995 PyObject * obj0 = 0 ;
16996 PyObject * obj1 = 0 ;
16997 PyObject * obj2 = 0 ;
16998 PyObject * obj3 = 0 ;
16999 char *kwnames[] = {
17000 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17001 };
17002
17003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17005 if (SWIG_arg_fail(1)) SWIG_fail;
17006 arg2 = obj1;
17007 arg3 = obj2;
17008 arg4 = obj3;
17009 {
17010 PyThreadState* __tstate = wxPyBeginAllowThreads();
17011 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
17012
17013 wxPyEndAllowThreads(__tstate);
17014 if (PyErr_Occurred()) SWIG_fail;
17015 }
17016 resultobj = result;
17017 return resultobj;
17018 fail:
17019 return NULL;
17020 }
17021
17022
17023 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
17024 PyObject *resultobj;
17025 wxDC *arg1 = (wxDC *) 0 ;
17026 PyObject *arg2 = (PyObject *) 0 ;
17027 PyObject *arg3 = (PyObject *) 0 ;
17028 PyObject *arg4 = (PyObject *) 0 ;
17029 PyObject *result;
17030 PyObject * obj0 = 0 ;
17031 PyObject * obj1 = 0 ;
17032 PyObject * obj2 = 0 ;
17033 PyObject * obj3 = 0 ;
17034 char *kwnames[] = {
17035 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17036 };
17037
17038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17040 if (SWIG_arg_fail(1)) SWIG_fail;
17041 arg2 = obj1;
17042 arg3 = obj2;
17043 arg4 = obj3;
17044 {
17045 PyThreadState* __tstate = wxPyBeginAllowThreads();
17046 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17047
17048 wxPyEndAllowThreads(__tstate);
17049 if (PyErr_Occurred()) SWIG_fail;
17050 }
17051 resultobj = result;
17052 return resultobj;
17053 fail:
17054 return NULL;
17055 }
17056
17057
17058 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17059 PyObject *resultobj;
17060 wxDC *arg1 = (wxDC *) 0 ;
17061 PyObject *arg2 = (PyObject *) 0 ;
17062 PyObject *arg3 = (PyObject *) 0 ;
17063 PyObject *arg4 = (PyObject *) 0 ;
17064 PyObject *result;
17065 PyObject * obj0 = 0 ;
17066 PyObject * obj1 = 0 ;
17067 PyObject * obj2 = 0 ;
17068 PyObject * obj3 = 0 ;
17069 char *kwnames[] = {
17070 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17071 };
17072
17073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17075 if (SWIG_arg_fail(1)) SWIG_fail;
17076 arg2 = obj1;
17077 arg3 = obj2;
17078 arg4 = obj3;
17079 {
17080 PyThreadState* __tstate = wxPyBeginAllowThreads();
17081 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17082
17083 wxPyEndAllowThreads(__tstate);
17084 if (PyErr_Occurred()) SWIG_fail;
17085 }
17086 resultobj = result;
17087 return resultobj;
17088 fail:
17089 return NULL;
17090 }
17091
17092
17093 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17094 PyObject *resultobj;
17095 wxDC *arg1 = (wxDC *) 0 ;
17096 PyObject *arg2 = (PyObject *) 0 ;
17097 PyObject *arg3 = (PyObject *) 0 ;
17098 PyObject *arg4 = (PyObject *) 0 ;
17099 PyObject *result;
17100 PyObject * obj0 = 0 ;
17101 PyObject * obj1 = 0 ;
17102 PyObject * obj2 = 0 ;
17103 PyObject * obj3 = 0 ;
17104 char *kwnames[] = {
17105 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17106 };
17107
17108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17110 if (SWIG_arg_fail(1)) SWIG_fail;
17111 arg2 = obj1;
17112 arg3 = obj2;
17113 arg4 = obj3;
17114 {
17115 PyThreadState* __tstate = wxPyBeginAllowThreads();
17116 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17117
17118 wxPyEndAllowThreads(__tstate);
17119 if (PyErr_Occurred()) SWIG_fail;
17120 }
17121 resultobj = result;
17122 return resultobj;
17123 fail:
17124 return NULL;
17125 }
17126
17127
17128 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17129 PyObject *resultobj;
17130 wxDC *arg1 = (wxDC *) 0 ;
17131 PyObject *arg2 = (PyObject *) 0 ;
17132 PyObject *arg3 = (PyObject *) 0 ;
17133 PyObject *arg4 = (PyObject *) 0 ;
17134 PyObject *arg5 = (PyObject *) 0 ;
17135 PyObject *result;
17136 PyObject * obj0 = 0 ;
17137 PyObject * obj1 = 0 ;
17138 PyObject * obj2 = 0 ;
17139 PyObject * obj3 = 0 ;
17140 PyObject * obj4 = 0 ;
17141 char *kwnames[] = {
17142 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17143 };
17144
17145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17147 if (SWIG_arg_fail(1)) SWIG_fail;
17148 arg2 = obj1;
17149 arg3 = obj2;
17150 arg4 = obj3;
17151 arg5 = obj4;
17152 {
17153 PyThreadState* __tstate = wxPyBeginAllowThreads();
17154 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17155
17156 wxPyEndAllowThreads(__tstate);
17157 if (PyErr_Occurred()) SWIG_fail;
17158 }
17159 resultobj = result;
17160 return resultobj;
17161 fail:
17162 return NULL;
17163 }
17164
17165
17166 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17167 PyObject *obj;
17168 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17169 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17170 Py_INCREF(obj);
17171 return Py_BuildValue((char *)"");
17172 }
17173 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17174 PyObject *resultobj;
17175 wxMemoryDC *result;
17176 char *kwnames[] = {
17177 NULL
17178 };
17179
17180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17181 {
17182 if (!wxPyCheckForApp()) SWIG_fail;
17183 PyThreadState* __tstate = wxPyBeginAllowThreads();
17184 result = (wxMemoryDC *)new wxMemoryDC();
17185
17186 wxPyEndAllowThreads(__tstate);
17187 if (PyErr_Occurred()) SWIG_fail;
17188 }
17189 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17190 return resultobj;
17191 fail:
17192 return NULL;
17193 }
17194
17195
17196 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17197 PyObject *resultobj;
17198 wxDC *arg1 = (wxDC *) 0 ;
17199 wxMemoryDC *result;
17200 PyObject * obj0 = 0 ;
17201 char *kwnames[] = {
17202 (char *) "oldDC", NULL
17203 };
17204
17205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17207 if (SWIG_arg_fail(1)) SWIG_fail;
17208 {
17209 if (!wxPyCheckForApp()) SWIG_fail;
17210 PyThreadState* __tstate = wxPyBeginAllowThreads();
17211 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17212
17213 wxPyEndAllowThreads(__tstate);
17214 if (PyErr_Occurred()) SWIG_fail;
17215 }
17216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17217 return resultobj;
17218 fail:
17219 return NULL;
17220 }
17221
17222
17223 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17224 PyObject *resultobj;
17225 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17226 wxBitmap *arg2 = 0 ;
17227 PyObject * obj0 = 0 ;
17228 PyObject * obj1 = 0 ;
17229 char *kwnames[] = {
17230 (char *) "self",(char *) "bitmap", NULL
17231 };
17232
17233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17235 if (SWIG_arg_fail(1)) SWIG_fail;
17236 {
17237 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17238 if (SWIG_arg_fail(2)) SWIG_fail;
17239 if (arg2 == NULL) {
17240 SWIG_null_ref("wxBitmap");
17241 }
17242 if (SWIG_arg_fail(2)) SWIG_fail;
17243 }
17244 {
17245 PyThreadState* __tstate = wxPyBeginAllowThreads();
17246 (arg1)->SelectObject((wxBitmap const &)*arg2);
17247
17248 wxPyEndAllowThreads(__tstate);
17249 if (PyErr_Occurred()) SWIG_fail;
17250 }
17251 Py_INCREF(Py_None); resultobj = Py_None;
17252 return resultobj;
17253 fail:
17254 return NULL;
17255 }
17256
17257
17258 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17259 PyObject *obj;
17260 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17261 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17262 Py_INCREF(obj);
17263 return Py_BuildValue((char *)"");
17264 }
17265 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17266 PyObject *resultobj;
17267 wxDC *arg1 = (wxDC *) 0 ;
17268 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17269 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17270 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17271 wxBufferedDC *result;
17272 PyObject * obj0 = 0 ;
17273 PyObject * obj1 = 0 ;
17274 PyObject * obj2 = 0 ;
17275
17276 if(!PyArg_ParseTuple(args,(char *)"O|OO:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17278 if (SWIG_arg_fail(1)) SWIG_fail;
17279 if (obj1) {
17280 {
17281 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17282 if (SWIG_arg_fail(2)) SWIG_fail;
17283 if (arg2 == NULL) {
17284 SWIG_null_ref("wxBitmap");
17285 }
17286 if (SWIG_arg_fail(2)) SWIG_fail;
17287 }
17288 }
17289 if (obj2) {
17290 {
17291 arg3 = (int)(SWIG_As_int(obj2));
17292 if (SWIG_arg_fail(3)) SWIG_fail;
17293 }
17294 }
17295 {
17296 if (!wxPyCheckForApp()) SWIG_fail;
17297 PyThreadState* __tstate = wxPyBeginAllowThreads();
17298 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
17299
17300 wxPyEndAllowThreads(__tstate);
17301 if (PyErr_Occurred()) SWIG_fail;
17302 }
17303 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17304 return resultobj;
17305 fail:
17306 return NULL;
17307 }
17308
17309
17310 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17311 PyObject *resultobj;
17312 wxDC *arg1 = (wxDC *) 0 ;
17313 wxSize *arg2 = 0 ;
17314 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17315 wxBufferedDC *result;
17316 wxSize temp2 ;
17317 PyObject * obj0 = 0 ;
17318 PyObject * obj1 = 0 ;
17319 PyObject * obj2 = 0 ;
17320
17321 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17323 if (SWIG_arg_fail(1)) SWIG_fail;
17324 {
17325 arg2 = &temp2;
17326 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17327 }
17328 if (obj2) {
17329 {
17330 arg3 = (int)(SWIG_As_int(obj2));
17331 if (SWIG_arg_fail(3)) SWIG_fail;
17332 }
17333 }
17334 {
17335 if (!wxPyCheckForApp()) SWIG_fail;
17336 PyThreadState* __tstate = wxPyBeginAllowThreads();
17337 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
17338
17339 wxPyEndAllowThreads(__tstate);
17340 if (PyErr_Occurred()) SWIG_fail;
17341 }
17342 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17343 return resultobj;
17344 fail:
17345 return NULL;
17346 }
17347
17348
17349 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
17350 int argc;
17351 PyObject *argv[4];
17352 int ii;
17353
17354 argc = PyObject_Length(args);
17355 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
17356 argv[ii] = PyTuple_GetItem(args,ii);
17357 }
17358 if ((argc >= 1) && (argc <= 3)) {
17359 int _v;
17360 {
17361 void *ptr;
17362 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17363 _v = 0;
17364 PyErr_Clear();
17365 } else {
17366 _v = 1;
17367 }
17368 }
17369 if (_v) {
17370 if (argc <= 1) {
17371 return _wrap_new_BufferedDC__SWIG_0(self,args);
17372 }
17373 {
17374 void *ptr = 0;
17375 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
17376 _v = 0;
17377 PyErr_Clear();
17378 } else {
17379 _v = (ptr != 0);
17380 }
17381 }
17382 if (_v) {
17383 if (argc <= 2) {
17384 return _wrap_new_BufferedDC__SWIG_0(self,args);
17385 }
17386 _v = SWIG_Check_int(argv[2]);
17387 if (_v) {
17388 return _wrap_new_BufferedDC__SWIG_0(self,args);
17389 }
17390 }
17391 }
17392 }
17393 if ((argc >= 2) && (argc <= 3)) {
17394 int _v;
17395 {
17396 void *ptr;
17397 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17398 _v = 0;
17399 PyErr_Clear();
17400 } else {
17401 _v = 1;
17402 }
17403 }
17404 if (_v) {
17405 {
17406 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
17407 }
17408 if (_v) {
17409 if (argc <= 2) {
17410 return _wrap_new_BufferedDC__SWIG_1(self,args);
17411 }
17412 _v = SWIG_Check_int(argv[2]);
17413 if (_v) {
17414 return _wrap_new_BufferedDC__SWIG_1(self,args);
17415 }
17416 }
17417 }
17418 }
17419
17420 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
17421 return NULL;
17422 }
17423
17424
17425 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
17426 PyObject *resultobj;
17427 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17428 PyObject * obj0 = 0 ;
17429 char *kwnames[] = {
17430 (char *) "self", NULL
17431 };
17432
17433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
17434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17435 if (SWIG_arg_fail(1)) SWIG_fail;
17436 {
17437 PyThreadState* __tstate = wxPyBeginAllowThreads();
17438 delete arg1;
17439
17440 wxPyEndAllowThreads(__tstate);
17441 if (PyErr_Occurred()) SWIG_fail;
17442 }
17443 Py_INCREF(Py_None); resultobj = Py_None;
17444 return resultobj;
17445 fail:
17446 return NULL;
17447 }
17448
17449
17450 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
17451 PyObject *resultobj;
17452 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17453 PyObject * obj0 = 0 ;
17454 char *kwnames[] = {
17455 (char *) "self", NULL
17456 };
17457
17458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
17459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17460 if (SWIG_arg_fail(1)) SWIG_fail;
17461 {
17462 PyThreadState* __tstate = wxPyBeginAllowThreads();
17463 (arg1)->UnMask();
17464
17465 wxPyEndAllowThreads(__tstate);
17466 if (PyErr_Occurred()) SWIG_fail;
17467 }
17468 Py_INCREF(Py_None); resultobj = Py_None;
17469 return resultobj;
17470 fail:
17471 return NULL;
17472 }
17473
17474
17475 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
17476 PyObject *obj;
17477 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17478 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
17479 Py_INCREF(obj);
17480 return Py_BuildValue((char *)"");
17481 }
17482 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17483 PyObject *resultobj;
17484 wxWindow *arg1 = (wxWindow *) 0 ;
17485 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17486 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17487 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17488 wxBufferedPaintDC *result;
17489 PyObject * obj0 = 0 ;
17490 PyObject * obj1 = 0 ;
17491 PyObject * obj2 = 0 ;
17492 char *kwnames[] = {
17493 (char *) "window",(char *) "buffer",(char *) "style", NULL
17494 };
17495
17496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
17497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17498 if (SWIG_arg_fail(1)) SWIG_fail;
17499 if (obj1) {
17500 {
17501 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17502 if (SWIG_arg_fail(2)) SWIG_fail;
17503 if (arg2 == NULL) {
17504 SWIG_null_ref("wxBitmap");
17505 }
17506 if (SWIG_arg_fail(2)) SWIG_fail;
17507 }
17508 }
17509 if (obj2) {
17510 {
17511 arg3 = (int)(SWIG_As_int(obj2));
17512 if (SWIG_arg_fail(3)) SWIG_fail;
17513 }
17514 }
17515 {
17516 if (!wxPyCheckForApp()) SWIG_fail;
17517 PyThreadState* __tstate = wxPyBeginAllowThreads();
17518 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
17519
17520 wxPyEndAllowThreads(__tstate);
17521 if (PyErr_Occurred()) SWIG_fail;
17522 }
17523 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
17524 return resultobj;
17525 fail:
17526 return NULL;
17527 }
17528
17529
17530 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
17531 PyObject *obj;
17532 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17533 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
17534 Py_INCREF(obj);
17535 return Py_BuildValue((char *)"");
17536 }
17537 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
17538 PyObject *resultobj;
17539 wxScreenDC *result;
17540 char *kwnames[] = {
17541 NULL
17542 };
17543
17544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
17545 {
17546 if (!wxPyCheckForApp()) SWIG_fail;
17547 PyThreadState* __tstate = wxPyBeginAllowThreads();
17548 result = (wxScreenDC *)new wxScreenDC();
17549
17550 wxPyEndAllowThreads(__tstate);
17551 if (PyErr_Occurred()) SWIG_fail;
17552 }
17553 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
17554 return resultobj;
17555 fail:
17556 return NULL;
17557 }
17558
17559
17560 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
17561 PyObject *resultobj;
17562 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17563 wxWindow *arg2 = (wxWindow *) 0 ;
17564 bool result;
17565 PyObject * obj0 = 0 ;
17566 PyObject * obj1 = 0 ;
17567 char *kwnames[] = {
17568 (char *) "self",(char *) "window", NULL
17569 };
17570
17571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
17572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17573 if (SWIG_arg_fail(1)) SWIG_fail;
17574 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17575 if (SWIG_arg_fail(2)) SWIG_fail;
17576 {
17577 PyThreadState* __tstate = wxPyBeginAllowThreads();
17578 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17579
17580 wxPyEndAllowThreads(__tstate);
17581 if (PyErr_Occurred()) SWIG_fail;
17582 }
17583 {
17584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17585 }
17586 return resultobj;
17587 fail:
17588 return NULL;
17589 }
17590
17591
17592 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17593 PyObject *resultobj;
17594 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17595 wxRect *arg2 = (wxRect *) NULL ;
17596 bool result;
17597 PyObject * obj0 = 0 ;
17598 PyObject * obj1 = 0 ;
17599 char *kwnames[] = {
17600 (char *) "self",(char *) "rect", NULL
17601 };
17602
17603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
17604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17605 if (SWIG_arg_fail(1)) SWIG_fail;
17606 if (obj1) {
17607 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
17608 if (SWIG_arg_fail(2)) SWIG_fail;
17609 }
17610 {
17611 PyThreadState* __tstate = wxPyBeginAllowThreads();
17612 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17613
17614 wxPyEndAllowThreads(__tstate);
17615 if (PyErr_Occurred()) SWIG_fail;
17616 }
17617 {
17618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17619 }
17620 return resultobj;
17621 fail:
17622 return NULL;
17623 }
17624
17625
17626 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17627 PyObject *resultobj;
17628 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17629 bool result;
17630 PyObject * obj0 = 0 ;
17631 char *kwnames[] = {
17632 (char *) "self", NULL
17633 };
17634
17635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
17636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17637 if (SWIG_arg_fail(1)) SWIG_fail;
17638 {
17639 PyThreadState* __tstate = wxPyBeginAllowThreads();
17640 result = (bool)(arg1)->EndDrawingOnTop();
17641
17642 wxPyEndAllowThreads(__tstate);
17643 if (PyErr_Occurred()) SWIG_fail;
17644 }
17645 {
17646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17647 }
17648 return resultobj;
17649 fail:
17650 return NULL;
17651 }
17652
17653
17654 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
17655 PyObject *obj;
17656 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17657 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
17658 Py_INCREF(obj);
17659 return Py_BuildValue((char *)"");
17660 }
17661 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
17662 PyObject *resultobj;
17663 wxWindow *arg1 = (wxWindow *) 0 ;
17664 wxClientDC *result;
17665 PyObject * obj0 = 0 ;
17666 char *kwnames[] = {
17667 (char *) "win", NULL
17668 };
17669
17670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
17671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17672 if (SWIG_arg_fail(1)) SWIG_fail;
17673 {
17674 if (!wxPyCheckForApp()) SWIG_fail;
17675 PyThreadState* __tstate = wxPyBeginAllowThreads();
17676 result = (wxClientDC *)new wxClientDC(arg1);
17677
17678 wxPyEndAllowThreads(__tstate);
17679 if (PyErr_Occurred()) SWIG_fail;
17680 }
17681 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
17682 return resultobj;
17683 fail:
17684 return NULL;
17685 }
17686
17687
17688 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
17689 PyObject *obj;
17690 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17691 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
17692 Py_INCREF(obj);
17693 return Py_BuildValue((char *)"");
17694 }
17695 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17696 PyObject *resultobj;
17697 wxWindow *arg1 = (wxWindow *) 0 ;
17698 wxPaintDC *result;
17699 PyObject * obj0 = 0 ;
17700 char *kwnames[] = {
17701 (char *) "win", NULL
17702 };
17703
17704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
17705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17706 if (SWIG_arg_fail(1)) SWIG_fail;
17707 {
17708 if (!wxPyCheckForApp()) SWIG_fail;
17709 PyThreadState* __tstate = wxPyBeginAllowThreads();
17710 result = (wxPaintDC *)new wxPaintDC(arg1);
17711
17712 wxPyEndAllowThreads(__tstate);
17713 if (PyErr_Occurred()) SWIG_fail;
17714 }
17715 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
17716 return resultobj;
17717 fail:
17718 return NULL;
17719 }
17720
17721
17722 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
17723 PyObject *obj;
17724 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17725 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
17726 Py_INCREF(obj);
17727 return Py_BuildValue((char *)"");
17728 }
17729 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
17730 PyObject *resultobj;
17731 wxWindow *arg1 = (wxWindow *) 0 ;
17732 wxWindowDC *result;
17733 PyObject * obj0 = 0 ;
17734 char *kwnames[] = {
17735 (char *) "win", NULL
17736 };
17737
17738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
17739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17740 if (SWIG_arg_fail(1)) SWIG_fail;
17741 {
17742 if (!wxPyCheckForApp()) SWIG_fail;
17743 PyThreadState* __tstate = wxPyBeginAllowThreads();
17744 result = (wxWindowDC *)new wxWindowDC(arg1);
17745
17746 wxPyEndAllowThreads(__tstate);
17747 if (PyErr_Occurred()) SWIG_fail;
17748 }
17749 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
17750 return resultobj;
17751 fail:
17752 return NULL;
17753 }
17754
17755
17756 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
17757 PyObject *obj;
17758 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17759 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
17760 Py_INCREF(obj);
17761 return Py_BuildValue((char *)"");
17762 }
17763 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
17764 PyObject *resultobj;
17765 wxDC *arg1 = 0 ;
17766 bool arg2 ;
17767 wxMirrorDC *result;
17768 PyObject * obj0 = 0 ;
17769 PyObject * obj1 = 0 ;
17770 char *kwnames[] = {
17771 (char *) "dc",(char *) "mirror", NULL
17772 };
17773
17774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
17775 {
17776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17777 if (SWIG_arg_fail(1)) SWIG_fail;
17778 if (arg1 == NULL) {
17779 SWIG_null_ref("wxDC");
17780 }
17781 if (SWIG_arg_fail(1)) SWIG_fail;
17782 }
17783 {
17784 arg2 = (bool)(SWIG_As_bool(obj1));
17785 if (SWIG_arg_fail(2)) SWIG_fail;
17786 }
17787 {
17788 if (!wxPyCheckForApp()) SWIG_fail;
17789 PyThreadState* __tstate = wxPyBeginAllowThreads();
17790 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
17791
17792 wxPyEndAllowThreads(__tstate);
17793 if (PyErr_Occurred()) SWIG_fail;
17794 }
17795 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
17796 return resultobj;
17797 fail:
17798 return NULL;
17799 }
17800
17801
17802 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
17803 PyObject *obj;
17804 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17805 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
17806 Py_INCREF(obj);
17807 return Py_BuildValue((char *)"");
17808 }
17809 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
17810 PyObject *resultobj;
17811 wxPrintData *arg1 = 0 ;
17812 wxPostScriptDC *result;
17813 PyObject * obj0 = 0 ;
17814 char *kwnames[] = {
17815 (char *) "printData", NULL
17816 };
17817
17818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
17819 {
17820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17821 if (SWIG_arg_fail(1)) SWIG_fail;
17822 if (arg1 == NULL) {
17823 SWIG_null_ref("wxPrintData");
17824 }
17825 if (SWIG_arg_fail(1)) SWIG_fail;
17826 }
17827 {
17828 if (!wxPyCheckForApp()) SWIG_fail;
17829 PyThreadState* __tstate = wxPyBeginAllowThreads();
17830 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
17831
17832 wxPyEndAllowThreads(__tstate);
17833 if (PyErr_Occurred()) SWIG_fail;
17834 }
17835 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
17836 return resultobj;
17837 fail:
17838 return NULL;
17839 }
17840
17841
17842 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17843 PyObject *resultobj;
17844 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17845 wxPrintData *result;
17846 PyObject * obj0 = 0 ;
17847 char *kwnames[] = {
17848 (char *) "self", NULL
17849 };
17850
17851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
17852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17853 if (SWIG_arg_fail(1)) SWIG_fail;
17854 {
17855 PyThreadState* __tstate = wxPyBeginAllowThreads();
17856 {
17857 wxPrintData &_result_ref = (arg1)->GetPrintData();
17858 result = (wxPrintData *) &_result_ref;
17859 }
17860
17861 wxPyEndAllowThreads(__tstate);
17862 if (PyErr_Occurred()) SWIG_fail;
17863 }
17864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
17865 return resultobj;
17866 fail:
17867 return NULL;
17868 }
17869
17870
17871 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17872 PyObject *resultobj;
17873 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17874 wxPrintData *arg2 = 0 ;
17875 PyObject * obj0 = 0 ;
17876 PyObject * obj1 = 0 ;
17877 char *kwnames[] = {
17878 (char *) "self",(char *) "data", NULL
17879 };
17880
17881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
17882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17883 if (SWIG_arg_fail(1)) SWIG_fail;
17884 {
17885 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17886 if (SWIG_arg_fail(2)) SWIG_fail;
17887 if (arg2 == NULL) {
17888 SWIG_null_ref("wxPrintData");
17889 }
17890 if (SWIG_arg_fail(2)) SWIG_fail;
17891 }
17892 {
17893 PyThreadState* __tstate = wxPyBeginAllowThreads();
17894 (arg1)->SetPrintData((wxPrintData const &)*arg2);
17895
17896 wxPyEndAllowThreads(__tstate);
17897 if (PyErr_Occurred()) SWIG_fail;
17898 }
17899 Py_INCREF(Py_None); resultobj = Py_None;
17900 return resultobj;
17901 fail:
17902 return NULL;
17903 }
17904
17905
17906 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17907 PyObject *resultobj;
17908 int arg1 ;
17909 PyObject * obj0 = 0 ;
17910 char *kwnames[] = {
17911 (char *) "ppi", NULL
17912 };
17913
17914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
17915 {
17916 arg1 = (int)(SWIG_As_int(obj0));
17917 if (SWIG_arg_fail(1)) SWIG_fail;
17918 }
17919 {
17920 PyThreadState* __tstate = wxPyBeginAllowThreads();
17921 wxPostScriptDC::SetResolution(arg1);
17922
17923 wxPyEndAllowThreads(__tstate);
17924 if (PyErr_Occurred()) SWIG_fail;
17925 }
17926 Py_INCREF(Py_None); resultobj = Py_None;
17927 return resultobj;
17928 fail:
17929 return NULL;
17930 }
17931
17932
17933 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17934 PyObject *resultobj;
17935 int result;
17936 char *kwnames[] = {
17937 NULL
17938 };
17939
17940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
17941 {
17942 PyThreadState* __tstate = wxPyBeginAllowThreads();
17943 result = (int)wxPostScriptDC::GetResolution();
17944
17945 wxPyEndAllowThreads(__tstate);
17946 if (PyErr_Occurred()) SWIG_fail;
17947 }
17948 {
17949 resultobj = SWIG_From_int((int)(result));
17950 }
17951 return resultobj;
17952 fail:
17953 return NULL;
17954 }
17955
17956
17957 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
17958 PyObject *obj;
17959 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17960 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
17961 Py_INCREF(obj);
17962 return Py_BuildValue((char *)"");
17963 }
17964 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
17965 PyObject *resultobj;
17966 wxString const &arg1_defvalue = wxPyEmptyString ;
17967 wxString *arg1 = (wxString *) &arg1_defvalue ;
17968 wxMetaFile *result;
17969 bool temp1 = false ;
17970 PyObject * obj0 = 0 ;
17971 char *kwnames[] = {
17972 (char *) "filename", NULL
17973 };
17974
17975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
17976 if (obj0) {
17977 {
17978 arg1 = wxString_in_helper(obj0);
17979 if (arg1 == NULL) SWIG_fail;
17980 temp1 = true;
17981 }
17982 }
17983 {
17984 if (!wxPyCheckForApp()) SWIG_fail;
17985 PyThreadState* __tstate = wxPyBeginAllowThreads();
17986 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
17987
17988 wxPyEndAllowThreads(__tstate);
17989 if (PyErr_Occurred()) SWIG_fail;
17990 }
17991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
17992 {
17993 if (temp1)
17994 delete arg1;
17995 }
17996 return resultobj;
17997 fail:
17998 {
17999 if (temp1)
18000 delete arg1;
18001 }
18002 return NULL;
18003 }
18004
18005
18006 static PyObject *_wrap_delete_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18007 PyObject *resultobj;
18008 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18009 PyObject * obj0 = 0 ;
18010 char *kwnames[] = {
18011 (char *) "self", NULL
18012 };
18013
18014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MetaFile",kwnames,&obj0)) goto fail;
18015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18016 if (SWIG_arg_fail(1)) SWIG_fail;
18017 {
18018 PyThreadState* __tstate = wxPyBeginAllowThreads();
18019 delete arg1;
18020
18021 wxPyEndAllowThreads(__tstate);
18022 if (PyErr_Occurred()) SWIG_fail;
18023 }
18024 Py_INCREF(Py_None); resultobj = Py_None;
18025 return resultobj;
18026 fail:
18027 return NULL;
18028 }
18029
18030
18031 static PyObject *_wrap_MetaFile_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
18032 PyObject *resultobj;
18033 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18034 bool result;
18035 PyObject * obj0 = 0 ;
18036 char *kwnames[] = {
18037 (char *) "self", NULL
18038 };
18039
18040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_Ok",kwnames,&obj0)) goto fail;
18041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18042 if (SWIG_arg_fail(1)) SWIG_fail;
18043 {
18044 PyThreadState* __tstate = wxPyBeginAllowThreads();
18045 result = (bool)(arg1)->Ok();
18046
18047 wxPyEndAllowThreads(__tstate);
18048 if (PyErr_Occurred()) SWIG_fail;
18049 }
18050 {
18051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18052 }
18053 return resultobj;
18054 fail:
18055 return NULL;
18056 }
18057
18058
18059 static PyObject *_wrap_MetaFile_SetClipboard(PyObject *, PyObject *args, PyObject *kwargs) {
18060 PyObject *resultobj;
18061 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18062 int arg2 = (int) 0 ;
18063 int arg3 = (int) 0 ;
18064 bool result;
18065 PyObject * obj0 = 0 ;
18066 PyObject * obj1 = 0 ;
18067 PyObject * obj2 = 0 ;
18068 char *kwnames[] = {
18069 (char *) "self",(char *) "width",(char *) "height", NULL
18070 };
18071
18072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MetaFile_SetClipboard",kwnames,&obj0,&obj1,&obj2)) goto fail;
18073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18074 if (SWIG_arg_fail(1)) SWIG_fail;
18075 if (obj1) {
18076 {
18077 arg2 = (int)(SWIG_As_int(obj1));
18078 if (SWIG_arg_fail(2)) SWIG_fail;
18079 }
18080 }
18081 if (obj2) {
18082 {
18083 arg3 = (int)(SWIG_As_int(obj2));
18084 if (SWIG_arg_fail(3)) SWIG_fail;
18085 }
18086 }
18087 {
18088 PyThreadState* __tstate = wxPyBeginAllowThreads();
18089 result = (bool)(arg1)->SetClipboard(arg2,arg3);
18090
18091 wxPyEndAllowThreads(__tstate);
18092 if (PyErr_Occurred()) SWIG_fail;
18093 }
18094 {
18095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18096 }
18097 return resultobj;
18098 fail:
18099 return NULL;
18100 }
18101
18102
18103 static PyObject *_wrap_MetaFile_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18104 PyObject *resultobj;
18105 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18106 wxSize result;
18107 PyObject * obj0 = 0 ;
18108 char *kwnames[] = {
18109 (char *) "self", NULL
18110 };
18111
18112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetSize",kwnames,&obj0)) goto fail;
18113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18114 if (SWIG_arg_fail(1)) SWIG_fail;
18115 {
18116 PyThreadState* __tstate = wxPyBeginAllowThreads();
18117 result = (arg1)->GetSize();
18118
18119 wxPyEndAllowThreads(__tstate);
18120 if (PyErr_Occurred()) SWIG_fail;
18121 }
18122 {
18123 wxSize * resultptr;
18124 resultptr = new wxSize((wxSize &)(result));
18125 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18126 }
18127 return resultobj;
18128 fail:
18129 return NULL;
18130 }
18131
18132
18133 static PyObject *_wrap_MetaFile_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
18134 PyObject *resultobj;
18135 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18136 int result;
18137 PyObject * obj0 = 0 ;
18138 char *kwnames[] = {
18139 (char *) "self", NULL
18140 };
18141
18142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetWidth",kwnames,&obj0)) goto fail;
18143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18144 if (SWIG_arg_fail(1)) SWIG_fail;
18145 {
18146 PyThreadState* __tstate = wxPyBeginAllowThreads();
18147 result = (int)(arg1)->GetWidth();
18148
18149 wxPyEndAllowThreads(__tstate);
18150 if (PyErr_Occurred()) SWIG_fail;
18151 }
18152 {
18153 resultobj = SWIG_From_int((int)(result));
18154 }
18155 return resultobj;
18156 fail:
18157 return NULL;
18158 }
18159
18160
18161 static PyObject *_wrap_MetaFile_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
18162 PyObject *resultobj;
18163 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18164 int result;
18165 PyObject * obj0 = 0 ;
18166 char *kwnames[] = {
18167 (char *) "self", NULL
18168 };
18169
18170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetHeight",kwnames,&obj0)) goto fail;
18171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18172 if (SWIG_arg_fail(1)) SWIG_fail;
18173 {
18174 PyThreadState* __tstate = wxPyBeginAllowThreads();
18175 result = (int)(arg1)->GetHeight();
18176
18177 wxPyEndAllowThreads(__tstate);
18178 if (PyErr_Occurred()) SWIG_fail;
18179 }
18180 {
18181 resultobj = SWIG_From_int((int)(result));
18182 }
18183 return resultobj;
18184 fail:
18185 return NULL;
18186 }
18187
18188
18189 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
18190 PyObject *obj;
18191 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18192 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
18193 Py_INCREF(obj);
18194 return Py_BuildValue((char *)"");
18195 }
18196 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
18197 PyObject *resultobj;
18198 wxString const &arg1_defvalue = wxPyEmptyString ;
18199 wxString *arg1 = (wxString *) &arg1_defvalue ;
18200 int arg2 = (int) 0 ;
18201 int arg3 = (int) 0 ;
18202 wxString const &arg4_defvalue = wxPyEmptyString ;
18203 wxString *arg4 = (wxString *) &arg4_defvalue ;
18204 wxMetaFileDC *result;
18205 bool temp1 = false ;
18206 bool temp4 = false ;
18207 PyObject * obj0 = 0 ;
18208 PyObject * obj1 = 0 ;
18209 PyObject * obj2 = 0 ;
18210 PyObject * obj3 = 0 ;
18211 char *kwnames[] = {
18212 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
18213 };
18214
18215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18216 if (obj0) {
18217 {
18218 arg1 = wxString_in_helper(obj0);
18219 if (arg1 == NULL) SWIG_fail;
18220 temp1 = true;
18221 }
18222 }
18223 if (obj1) {
18224 {
18225 arg2 = (int)(SWIG_As_int(obj1));
18226 if (SWIG_arg_fail(2)) SWIG_fail;
18227 }
18228 }
18229 if (obj2) {
18230 {
18231 arg3 = (int)(SWIG_As_int(obj2));
18232 if (SWIG_arg_fail(3)) SWIG_fail;
18233 }
18234 }
18235 if (obj3) {
18236 {
18237 arg4 = wxString_in_helper(obj3);
18238 if (arg4 == NULL) SWIG_fail;
18239 temp4 = true;
18240 }
18241 }
18242 {
18243 if (!wxPyCheckForApp()) SWIG_fail;
18244 PyThreadState* __tstate = wxPyBeginAllowThreads();
18245 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
18246
18247 wxPyEndAllowThreads(__tstate);
18248 if (PyErr_Occurred()) SWIG_fail;
18249 }
18250 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
18251 {
18252 if (temp1)
18253 delete arg1;
18254 }
18255 {
18256 if (temp4)
18257 delete arg4;
18258 }
18259 return resultobj;
18260 fail:
18261 {
18262 if (temp1)
18263 delete arg1;
18264 }
18265 {
18266 if (temp4)
18267 delete arg4;
18268 }
18269 return NULL;
18270 }
18271
18272
18273 static PyObject *_wrap_MetaFileDC_Close(PyObject *, PyObject *args, PyObject *kwargs) {
18274 PyObject *resultobj;
18275 wxMetaFileDC *arg1 = (wxMetaFileDC *) 0 ;
18276 wxMetaFile *result;
18277 PyObject * obj0 = 0 ;
18278 char *kwnames[] = {
18279 (char *) "self", NULL
18280 };
18281
18282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFileDC_Close",kwnames,&obj0)) goto fail;
18283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFileDC, SWIG_POINTER_EXCEPTION | 0);
18284 if (SWIG_arg_fail(1)) SWIG_fail;
18285 {
18286 PyThreadState* __tstate = wxPyBeginAllowThreads();
18287 result = (wxMetaFile *)(arg1)->Close();
18288
18289 wxPyEndAllowThreads(__tstate);
18290 if (PyErr_Occurred()) SWIG_fail;
18291 }
18292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 0);
18293 return resultobj;
18294 fail:
18295 return NULL;
18296 }
18297
18298
18299 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
18300 PyObject *obj;
18301 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18302 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
18303 Py_INCREF(obj);
18304 return Py_BuildValue((char *)"");
18305 }
18306 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
18307 PyObject *resultobj;
18308 wxPrintData *arg1 = 0 ;
18309 wxPrinterDC *result;
18310 PyObject * obj0 = 0 ;
18311 char *kwnames[] = {
18312 (char *) "printData", NULL
18313 };
18314
18315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
18316 {
18317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18318 if (SWIG_arg_fail(1)) SWIG_fail;
18319 if (arg1 == NULL) {
18320 SWIG_null_ref("wxPrintData");
18321 }
18322 if (SWIG_arg_fail(1)) SWIG_fail;
18323 }
18324 {
18325 if (!wxPyCheckForApp()) SWIG_fail;
18326 PyThreadState* __tstate = wxPyBeginAllowThreads();
18327 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
18328
18329 wxPyEndAllowThreads(__tstate);
18330 if (PyErr_Occurred()) SWIG_fail;
18331 }
18332 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
18333 return resultobj;
18334 fail:
18335 return NULL;
18336 }
18337
18338
18339 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
18340 PyObject *obj;
18341 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18342 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
18343 Py_INCREF(obj);
18344 return Py_BuildValue((char *)"");
18345 }
18346 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18347 PyObject *resultobj;
18348 int arg1 ;
18349 int arg2 ;
18350 int arg3 = (int) true ;
18351 int arg4 = (int) 1 ;
18352 wxImageList *result;
18353 PyObject * obj0 = 0 ;
18354 PyObject * obj1 = 0 ;
18355 PyObject * obj2 = 0 ;
18356 PyObject * obj3 = 0 ;
18357 char *kwnames[] = {
18358 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
18359 };
18360
18361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18362 {
18363 arg1 = (int)(SWIG_As_int(obj0));
18364 if (SWIG_arg_fail(1)) SWIG_fail;
18365 }
18366 {
18367 arg2 = (int)(SWIG_As_int(obj1));
18368 if (SWIG_arg_fail(2)) SWIG_fail;
18369 }
18370 if (obj2) {
18371 {
18372 arg3 = (int)(SWIG_As_int(obj2));
18373 if (SWIG_arg_fail(3)) SWIG_fail;
18374 }
18375 }
18376 if (obj3) {
18377 {
18378 arg4 = (int)(SWIG_As_int(obj3));
18379 if (SWIG_arg_fail(4)) SWIG_fail;
18380 }
18381 }
18382 {
18383 if (!wxPyCheckForApp()) SWIG_fail;
18384 PyThreadState* __tstate = wxPyBeginAllowThreads();
18385 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
18386
18387 wxPyEndAllowThreads(__tstate);
18388 if (PyErr_Occurred()) SWIG_fail;
18389 }
18390 {
18391 resultobj = wxPyMake_wxObject(result, 1);
18392 }
18393 return resultobj;
18394 fail:
18395 return NULL;
18396 }
18397
18398
18399 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18400 PyObject *resultobj;
18401 wxImageList *arg1 = (wxImageList *) 0 ;
18402 PyObject * obj0 = 0 ;
18403 char *kwnames[] = {
18404 (char *) "self", NULL
18405 };
18406
18407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
18408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18409 if (SWIG_arg_fail(1)) SWIG_fail;
18410 {
18411 PyThreadState* __tstate = wxPyBeginAllowThreads();
18412 delete arg1;
18413
18414 wxPyEndAllowThreads(__tstate);
18415 if (PyErr_Occurred()) SWIG_fail;
18416 }
18417 Py_INCREF(Py_None); resultobj = Py_None;
18418 return resultobj;
18419 fail:
18420 return NULL;
18421 }
18422
18423
18424 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
18425 PyObject *resultobj;
18426 wxImageList *arg1 = (wxImageList *) 0 ;
18427 wxBitmap *arg2 = 0 ;
18428 wxBitmap const &arg3_defvalue = wxNullBitmap ;
18429 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
18430 int result;
18431 PyObject * obj0 = 0 ;
18432 PyObject * obj1 = 0 ;
18433 PyObject * obj2 = 0 ;
18434 char *kwnames[] = {
18435 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
18436 };
18437
18438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
18439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18440 if (SWIG_arg_fail(1)) SWIG_fail;
18441 {
18442 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18443 if (SWIG_arg_fail(2)) SWIG_fail;
18444 if (arg2 == NULL) {
18445 SWIG_null_ref("wxBitmap");
18446 }
18447 if (SWIG_arg_fail(2)) SWIG_fail;
18448 }
18449 if (obj2) {
18450 {
18451 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18452 if (SWIG_arg_fail(3)) SWIG_fail;
18453 if (arg3 == NULL) {
18454 SWIG_null_ref("wxBitmap");
18455 }
18456 if (SWIG_arg_fail(3)) SWIG_fail;
18457 }
18458 }
18459 {
18460 PyThreadState* __tstate = wxPyBeginAllowThreads();
18461 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
18462
18463 wxPyEndAllowThreads(__tstate);
18464 if (PyErr_Occurred()) SWIG_fail;
18465 }
18466 {
18467 resultobj = SWIG_From_int((int)(result));
18468 }
18469 return resultobj;
18470 fail:
18471 return NULL;
18472 }
18473
18474
18475 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
18476 PyObject *resultobj;
18477 wxImageList *arg1 = (wxImageList *) 0 ;
18478 wxBitmap *arg2 = 0 ;
18479 wxColour *arg3 = 0 ;
18480 int result;
18481 wxColour temp3 ;
18482 PyObject * obj0 = 0 ;
18483 PyObject * obj1 = 0 ;
18484 PyObject * obj2 = 0 ;
18485 char *kwnames[] = {
18486 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
18487 };
18488
18489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
18490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18491 if (SWIG_arg_fail(1)) SWIG_fail;
18492 {
18493 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18494 if (SWIG_arg_fail(2)) SWIG_fail;
18495 if (arg2 == NULL) {
18496 SWIG_null_ref("wxBitmap");
18497 }
18498 if (SWIG_arg_fail(2)) SWIG_fail;
18499 }
18500 {
18501 arg3 = &temp3;
18502 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
18503 }
18504 {
18505 PyThreadState* __tstate = wxPyBeginAllowThreads();
18506 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
18507
18508 wxPyEndAllowThreads(__tstate);
18509 if (PyErr_Occurred()) SWIG_fail;
18510 }
18511 {
18512 resultobj = SWIG_From_int((int)(result));
18513 }
18514 return resultobj;
18515 fail:
18516 return NULL;
18517 }
18518
18519
18520 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18521 PyObject *resultobj;
18522 wxImageList *arg1 = (wxImageList *) 0 ;
18523 wxIcon *arg2 = 0 ;
18524 int result;
18525 PyObject * obj0 = 0 ;
18526 PyObject * obj1 = 0 ;
18527 char *kwnames[] = {
18528 (char *) "self",(char *) "icon", NULL
18529 };
18530
18531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
18532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18533 if (SWIG_arg_fail(1)) SWIG_fail;
18534 {
18535 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
18536 if (SWIG_arg_fail(2)) SWIG_fail;
18537 if (arg2 == NULL) {
18538 SWIG_null_ref("wxIcon");
18539 }
18540 if (SWIG_arg_fail(2)) SWIG_fail;
18541 }
18542 {
18543 PyThreadState* __tstate = wxPyBeginAllowThreads();
18544 result = (int)(arg1)->Add((wxIcon const &)*arg2);
18545
18546 wxPyEndAllowThreads(__tstate);
18547 if (PyErr_Occurred()) SWIG_fail;
18548 }
18549 {
18550 resultobj = SWIG_From_int((int)(result));
18551 }
18552 return resultobj;
18553 fail:
18554 return NULL;
18555 }
18556
18557
18558 static PyObject *_wrap_ImageList_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
18559 PyObject *resultobj;
18560 wxImageList *arg1 = (wxImageList *) 0 ;
18561 int arg2 ;
18562 SwigValueWrapper<wxBitmap > result;
18563 PyObject * obj0 = 0 ;
18564 PyObject * obj1 = 0 ;
18565 char *kwnames[] = {
18566 (char *) "self",(char *) "index", NULL
18567 };
18568
18569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) goto fail;
18570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18571 if (SWIG_arg_fail(1)) SWIG_fail;
18572 {
18573 arg2 = (int)(SWIG_As_int(obj1));
18574 if (SWIG_arg_fail(2)) SWIG_fail;
18575 }
18576 {
18577 PyThreadState* __tstate = wxPyBeginAllowThreads();
18578 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
18579
18580 wxPyEndAllowThreads(__tstate);
18581 if (PyErr_Occurred()) SWIG_fail;
18582 }
18583 {
18584 wxBitmap * resultptr;
18585 resultptr = new wxBitmap((wxBitmap &)(result));
18586 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
18587 }
18588 return resultobj;
18589 fail:
18590 return NULL;
18591 }
18592
18593
18594 static PyObject *_wrap_ImageList_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18595 PyObject *resultobj;
18596 wxImageList *arg1 = (wxImageList *) 0 ;
18597 int arg2 ;
18598 wxIcon result;
18599 PyObject * obj0 = 0 ;
18600 PyObject * obj1 = 0 ;
18601 char *kwnames[] = {
18602 (char *) "self",(char *) "index", NULL
18603 };
18604
18605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) goto fail;
18606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18607 if (SWIG_arg_fail(1)) SWIG_fail;
18608 {
18609 arg2 = (int)(SWIG_As_int(obj1));
18610 if (SWIG_arg_fail(2)) SWIG_fail;
18611 }
18612 {
18613 PyThreadState* __tstate = wxPyBeginAllowThreads();
18614 result = ((wxImageList const *)arg1)->GetIcon(arg2);
18615
18616 wxPyEndAllowThreads(__tstate);
18617 if (PyErr_Occurred()) SWIG_fail;
18618 }
18619 {
18620 wxIcon * resultptr;
18621 resultptr = new wxIcon((wxIcon &)(result));
18622 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
18623 }
18624 return resultobj;
18625 fail:
18626 return NULL;
18627 }
18628
18629
18630 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
18631 PyObject *resultobj;
18632 wxImageList *arg1 = (wxImageList *) 0 ;
18633 int arg2 ;
18634 wxBitmap *arg3 = 0 ;
18635 bool result;
18636 PyObject * obj0 = 0 ;
18637 PyObject * obj1 = 0 ;
18638 PyObject * obj2 = 0 ;
18639 char *kwnames[] = {
18640 (char *) "self",(char *) "index",(char *) "bitmap", NULL
18641 };
18642
18643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_Replace",kwnames,&obj0,&obj1,&obj2)) goto fail;
18644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18645 if (SWIG_arg_fail(1)) SWIG_fail;
18646 {
18647 arg2 = (int)(SWIG_As_int(obj1));
18648 if (SWIG_arg_fail(2)) SWIG_fail;
18649 }
18650 {
18651 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18652 if (SWIG_arg_fail(3)) SWIG_fail;
18653 if (arg3 == NULL) {
18654 SWIG_null_ref("wxBitmap");
18655 }
18656 if (SWIG_arg_fail(3)) SWIG_fail;
18657 }
18658 {
18659 PyThreadState* __tstate = wxPyBeginAllowThreads();
18660 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3);
18661
18662 wxPyEndAllowThreads(__tstate);
18663 if (PyErr_Occurred()) SWIG_fail;
18664 }
18665 {
18666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18667 }
18668 return resultobj;
18669 fail:
18670 return NULL;
18671 }
18672
18673
18674 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
18675 PyObject *resultobj;
18676 wxImageList *arg1 = (wxImageList *) 0 ;
18677 int arg2 ;
18678 wxDC *arg3 = 0 ;
18679 int arg4 ;
18680 int arg5 ;
18681 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
18682 bool arg7 = (bool) (bool)false ;
18683 bool result;
18684 PyObject * obj0 = 0 ;
18685 PyObject * obj1 = 0 ;
18686 PyObject * obj2 = 0 ;
18687 PyObject * obj3 = 0 ;
18688 PyObject * obj4 = 0 ;
18689 PyObject * obj5 = 0 ;
18690 PyObject * obj6 = 0 ;
18691 char *kwnames[] = {
18692 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
18693 };
18694
18695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
18696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18697 if (SWIG_arg_fail(1)) SWIG_fail;
18698 {
18699 arg2 = (int)(SWIG_As_int(obj1));
18700 if (SWIG_arg_fail(2)) SWIG_fail;
18701 }
18702 {
18703 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18704 if (SWIG_arg_fail(3)) SWIG_fail;
18705 if (arg3 == NULL) {
18706 SWIG_null_ref("wxDC");
18707 }
18708 if (SWIG_arg_fail(3)) SWIG_fail;
18709 }
18710 {
18711 arg4 = (int)(SWIG_As_int(obj3));
18712 if (SWIG_arg_fail(4)) SWIG_fail;
18713 }
18714 {
18715 arg5 = (int)(SWIG_As_int(obj4));
18716 if (SWIG_arg_fail(5)) SWIG_fail;
18717 }
18718 if (obj5) {
18719 {
18720 arg6 = (int)(SWIG_As_int(obj5));
18721 if (SWIG_arg_fail(6)) SWIG_fail;
18722 }
18723 }
18724 if (obj6) {
18725 {
18726 arg7 = (bool const)(SWIG_As_bool(obj6));
18727 if (SWIG_arg_fail(7)) SWIG_fail;
18728 }
18729 }
18730 {
18731 PyThreadState* __tstate = wxPyBeginAllowThreads();
18732 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
18733
18734 wxPyEndAllowThreads(__tstate);
18735 if (PyErr_Occurred()) SWIG_fail;
18736 }
18737 {
18738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18739 }
18740 return resultobj;
18741 fail:
18742 return NULL;
18743 }
18744
18745
18746 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
18747 PyObject *resultobj;
18748 wxImageList *arg1 = (wxImageList *) 0 ;
18749 int result;
18750 PyObject * obj0 = 0 ;
18751 char *kwnames[] = {
18752 (char *) "self", NULL
18753 };
18754
18755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
18756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18757 if (SWIG_arg_fail(1)) SWIG_fail;
18758 {
18759 PyThreadState* __tstate = wxPyBeginAllowThreads();
18760 result = (int)(arg1)->GetImageCount();
18761
18762 wxPyEndAllowThreads(__tstate);
18763 if (PyErr_Occurred()) SWIG_fail;
18764 }
18765 {
18766 resultobj = SWIG_From_int((int)(result));
18767 }
18768 return resultobj;
18769 fail:
18770 return NULL;
18771 }
18772
18773
18774 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
18775 PyObject *resultobj;
18776 wxImageList *arg1 = (wxImageList *) 0 ;
18777 int arg2 ;
18778 bool result;
18779 PyObject * obj0 = 0 ;
18780 PyObject * obj1 = 0 ;
18781 char *kwnames[] = {
18782 (char *) "self",(char *) "index", NULL
18783 };
18784
18785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
18786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18787 if (SWIG_arg_fail(1)) SWIG_fail;
18788 {
18789 arg2 = (int)(SWIG_As_int(obj1));
18790 if (SWIG_arg_fail(2)) SWIG_fail;
18791 }
18792 {
18793 PyThreadState* __tstate = wxPyBeginAllowThreads();
18794 result = (bool)(arg1)->Remove(arg2);
18795
18796 wxPyEndAllowThreads(__tstate);
18797 if (PyErr_Occurred()) SWIG_fail;
18798 }
18799 {
18800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18801 }
18802 return resultobj;
18803 fail:
18804 return NULL;
18805 }
18806
18807
18808 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
18809 PyObject *resultobj;
18810 wxImageList *arg1 = (wxImageList *) 0 ;
18811 bool result;
18812 PyObject * obj0 = 0 ;
18813 char *kwnames[] = {
18814 (char *) "self", NULL
18815 };
18816
18817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
18818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18819 if (SWIG_arg_fail(1)) SWIG_fail;
18820 {
18821 PyThreadState* __tstate = wxPyBeginAllowThreads();
18822 result = (bool)(arg1)->RemoveAll();
18823
18824 wxPyEndAllowThreads(__tstate);
18825 if (PyErr_Occurred()) SWIG_fail;
18826 }
18827 {
18828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18829 }
18830 return resultobj;
18831 fail:
18832 return NULL;
18833 }
18834
18835
18836 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18837 PyObject *resultobj;
18838 wxImageList *arg1 = (wxImageList *) 0 ;
18839 int arg2 ;
18840 int *arg3 = 0 ;
18841 int *arg4 = 0 ;
18842 int temp3 ;
18843 int res3 = 0 ;
18844 int temp4 ;
18845 int res4 = 0 ;
18846 PyObject * obj0 = 0 ;
18847 PyObject * obj1 = 0 ;
18848 char *kwnames[] = {
18849 (char *) "self",(char *) "index", NULL
18850 };
18851
18852 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18853 arg4 = &temp4; res4 = SWIG_NEWOBJ;
18854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
18855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18856 if (SWIG_arg_fail(1)) SWIG_fail;
18857 {
18858 arg2 = (int)(SWIG_As_int(obj1));
18859 if (SWIG_arg_fail(2)) SWIG_fail;
18860 }
18861 {
18862 PyThreadState* __tstate = wxPyBeginAllowThreads();
18863 (arg1)->GetSize(arg2,*arg3,*arg4);
18864
18865 wxPyEndAllowThreads(__tstate);
18866 if (PyErr_Occurred()) SWIG_fail;
18867 }
18868 Py_INCREF(Py_None); resultobj = Py_None;
18869 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18870 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18871 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
18872 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
18873 return resultobj;
18874 fail:
18875 return NULL;
18876 }
18877
18878
18879 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
18880 PyObject *obj;
18881 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18882 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
18883 Py_INCREF(obj);
18884 return Py_BuildValue((char *)"");
18885 }
18886 static int _wrap_NORMAL_FONT_set(PyObject *) {
18887 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
18888 return 1;
18889 }
18890
18891
18892 static PyObject *_wrap_NORMAL_FONT_get(void) {
18893 PyObject *pyobj;
18894
18895 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
18896 return pyobj;
18897 }
18898
18899
18900 static int _wrap_SMALL_FONT_set(PyObject *) {
18901 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
18902 return 1;
18903 }
18904
18905
18906 static PyObject *_wrap_SMALL_FONT_get(void) {
18907 PyObject *pyobj;
18908
18909 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
18910 return pyobj;
18911 }
18912
18913
18914 static int _wrap_ITALIC_FONT_set(PyObject *) {
18915 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
18916 return 1;
18917 }
18918
18919
18920 static PyObject *_wrap_ITALIC_FONT_get(void) {
18921 PyObject *pyobj;
18922
18923 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
18924 return pyobj;
18925 }
18926
18927
18928 static int _wrap_SWISS_FONT_set(PyObject *) {
18929 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
18930 return 1;
18931 }
18932
18933
18934 static PyObject *_wrap_SWISS_FONT_get(void) {
18935 PyObject *pyobj;
18936
18937 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
18938 return pyobj;
18939 }
18940
18941
18942 static int _wrap_RED_PEN_set(PyObject *) {
18943 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
18944 return 1;
18945 }
18946
18947
18948 static PyObject *_wrap_RED_PEN_get(void) {
18949 PyObject *pyobj;
18950
18951 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
18952 return pyobj;
18953 }
18954
18955
18956 static int _wrap_CYAN_PEN_set(PyObject *) {
18957 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
18958 return 1;
18959 }
18960
18961
18962 static PyObject *_wrap_CYAN_PEN_get(void) {
18963 PyObject *pyobj;
18964
18965 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
18966 return pyobj;
18967 }
18968
18969
18970 static int _wrap_GREEN_PEN_set(PyObject *) {
18971 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
18972 return 1;
18973 }
18974
18975
18976 static PyObject *_wrap_GREEN_PEN_get(void) {
18977 PyObject *pyobj;
18978
18979 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
18980 return pyobj;
18981 }
18982
18983
18984 static int _wrap_BLACK_PEN_set(PyObject *) {
18985 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
18986 return 1;
18987 }
18988
18989
18990 static PyObject *_wrap_BLACK_PEN_get(void) {
18991 PyObject *pyobj;
18992
18993 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
18994 return pyobj;
18995 }
18996
18997
18998 static int _wrap_WHITE_PEN_set(PyObject *) {
18999 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
19000 return 1;
19001 }
19002
19003
19004 static PyObject *_wrap_WHITE_PEN_get(void) {
19005 PyObject *pyobj;
19006
19007 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
19008 return pyobj;
19009 }
19010
19011
19012 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
19013 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
19014 return 1;
19015 }
19016
19017
19018 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
19019 PyObject *pyobj;
19020
19021 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
19022 return pyobj;
19023 }
19024
19025
19026 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
19027 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
19028 return 1;
19029 }
19030
19031
19032 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
19033 PyObject *pyobj;
19034
19035 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
19036 return pyobj;
19037 }
19038
19039
19040 static int _wrap_GREY_PEN_set(PyObject *) {
19041 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
19042 return 1;
19043 }
19044
19045
19046 static PyObject *_wrap_GREY_PEN_get(void) {
19047 PyObject *pyobj;
19048
19049 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
19050 return pyobj;
19051 }
19052
19053
19054 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
19055 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
19056 return 1;
19057 }
19058
19059
19060 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
19061 PyObject *pyobj;
19062
19063 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19064 return pyobj;
19065 }
19066
19067
19068 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
19069 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
19070 return 1;
19071 }
19072
19073
19074 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
19075 PyObject *pyobj;
19076
19077 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19078 return pyobj;
19079 }
19080
19081
19082 static int _wrap_BLUE_BRUSH_set(PyObject *) {
19083 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
19084 return 1;
19085 }
19086
19087
19088 static PyObject *_wrap_BLUE_BRUSH_get(void) {
19089 PyObject *pyobj;
19090
19091 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19092 return pyobj;
19093 }
19094
19095
19096 static int _wrap_GREEN_BRUSH_set(PyObject *) {
19097 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
19098 return 1;
19099 }
19100
19101
19102 static PyObject *_wrap_GREEN_BRUSH_get(void) {
19103 PyObject *pyobj;
19104
19105 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19106 return pyobj;
19107 }
19108
19109
19110 static int _wrap_WHITE_BRUSH_set(PyObject *) {
19111 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
19112 return 1;
19113 }
19114
19115
19116 static PyObject *_wrap_WHITE_BRUSH_get(void) {
19117 PyObject *pyobj;
19118
19119 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19120 return pyobj;
19121 }
19122
19123
19124 static int _wrap_BLACK_BRUSH_set(PyObject *) {
19125 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
19126 return 1;
19127 }
19128
19129
19130 static PyObject *_wrap_BLACK_BRUSH_get(void) {
19131 PyObject *pyobj;
19132
19133 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
19134 return pyobj;
19135 }
19136
19137
19138 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
19139 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
19140 return 1;
19141 }
19142
19143
19144 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
19145 PyObject *pyobj;
19146
19147 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
19148 return pyobj;
19149 }
19150
19151
19152 static int _wrap_CYAN_BRUSH_set(PyObject *) {
19153 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
19154 return 1;
19155 }
19156
19157
19158 static PyObject *_wrap_CYAN_BRUSH_get(void) {
19159 PyObject *pyobj;
19160
19161 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19162 return pyobj;
19163 }
19164
19165
19166 static int _wrap_RED_BRUSH_set(PyObject *) {
19167 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
19168 return 1;
19169 }
19170
19171
19172 static PyObject *_wrap_RED_BRUSH_get(void) {
19173 PyObject *pyobj;
19174
19175 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
19176 return pyobj;
19177 }
19178
19179
19180 static int _wrap_GREY_BRUSH_set(PyObject *) {
19181 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
19182 return 1;
19183 }
19184
19185
19186 static PyObject *_wrap_GREY_BRUSH_get(void) {
19187 PyObject *pyobj;
19188
19189 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19190 return pyobj;
19191 }
19192
19193
19194 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
19195 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
19196 return 1;
19197 }
19198
19199
19200 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
19201 PyObject *pyobj;
19202
19203 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19204 return pyobj;
19205 }
19206
19207
19208 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
19209 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
19210 return 1;
19211 }
19212
19213
19214 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
19215 PyObject *pyobj;
19216
19217 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19218 return pyobj;
19219 }
19220
19221
19222 static int _wrap_BLACK_set(PyObject *) {
19223 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
19224 return 1;
19225 }
19226
19227
19228 static PyObject *_wrap_BLACK_get(void) {
19229 PyObject *pyobj;
19230
19231 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
19232 return pyobj;
19233 }
19234
19235
19236 static int _wrap_WHITE_set(PyObject *) {
19237 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
19238 return 1;
19239 }
19240
19241
19242 static PyObject *_wrap_WHITE_get(void) {
19243 PyObject *pyobj;
19244
19245 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
19246 return pyobj;
19247 }
19248
19249
19250 static int _wrap_RED_set(PyObject *) {
19251 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
19252 return 1;
19253 }
19254
19255
19256 static PyObject *_wrap_RED_get(void) {
19257 PyObject *pyobj;
19258
19259 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
19260 return pyobj;
19261 }
19262
19263
19264 static int _wrap_BLUE_set(PyObject *) {
19265 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
19266 return 1;
19267 }
19268
19269
19270 static PyObject *_wrap_BLUE_get(void) {
19271 PyObject *pyobj;
19272
19273 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
19274 return pyobj;
19275 }
19276
19277
19278 static int _wrap_GREEN_set(PyObject *) {
19279 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
19280 return 1;
19281 }
19282
19283
19284 static PyObject *_wrap_GREEN_get(void) {
19285 PyObject *pyobj;
19286
19287 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
19288 return pyobj;
19289 }
19290
19291
19292 static int _wrap_CYAN_set(PyObject *) {
19293 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
19294 return 1;
19295 }
19296
19297
19298 static PyObject *_wrap_CYAN_get(void) {
19299 PyObject *pyobj;
19300
19301 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
19302 return pyobj;
19303 }
19304
19305
19306 static int _wrap_LIGHT_GREY_set(PyObject *) {
19307 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
19308 return 1;
19309 }
19310
19311
19312 static PyObject *_wrap_LIGHT_GREY_get(void) {
19313 PyObject *pyobj;
19314
19315 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
19316 return pyobj;
19317 }
19318
19319
19320 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
19321 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
19322 return 1;
19323 }
19324
19325
19326 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
19327 PyObject *pyobj;
19328
19329 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
19330 return pyobj;
19331 }
19332
19333
19334 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
19335 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
19336 return 1;
19337 }
19338
19339
19340 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
19341 PyObject *pyobj;
19342
19343 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19344 return pyobj;
19345 }
19346
19347
19348 static int _wrap_CROSS_CURSOR_set(PyObject *) {
19349 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
19350 return 1;
19351 }
19352
19353
19354 static PyObject *_wrap_CROSS_CURSOR_get(void) {
19355 PyObject *pyobj;
19356
19357 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19358 return pyobj;
19359 }
19360
19361
19362 static int _wrap_NullBitmap_set(PyObject *) {
19363 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
19364 return 1;
19365 }
19366
19367
19368 static PyObject *_wrap_NullBitmap_get(void) {
19369 PyObject *pyobj;
19370
19371 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
19372 return pyobj;
19373 }
19374
19375
19376 static int _wrap_NullIcon_set(PyObject *) {
19377 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
19378 return 1;
19379 }
19380
19381
19382 static PyObject *_wrap_NullIcon_get(void) {
19383 PyObject *pyobj;
19384
19385 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
19386 return pyobj;
19387 }
19388
19389
19390 static int _wrap_NullCursor_set(PyObject *) {
19391 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
19392 return 1;
19393 }
19394
19395
19396 static PyObject *_wrap_NullCursor_get(void) {
19397 PyObject *pyobj;
19398
19399 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
19400 return pyobj;
19401 }
19402
19403
19404 static int _wrap_NullPen_set(PyObject *) {
19405 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
19406 return 1;
19407 }
19408
19409
19410 static PyObject *_wrap_NullPen_get(void) {
19411 PyObject *pyobj;
19412
19413 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
19414 return pyobj;
19415 }
19416
19417
19418 static int _wrap_NullBrush_set(PyObject *) {
19419 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
19420 return 1;
19421 }
19422
19423
19424 static PyObject *_wrap_NullBrush_get(void) {
19425 PyObject *pyobj;
19426
19427 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
19428 return pyobj;
19429 }
19430
19431
19432 static int _wrap_NullPalette_set(PyObject *) {
19433 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
19434 return 1;
19435 }
19436
19437
19438 static PyObject *_wrap_NullPalette_get(void) {
19439 PyObject *pyobj;
19440
19441 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
19442 return pyobj;
19443 }
19444
19445
19446 static int _wrap_NullFont_set(PyObject *) {
19447 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
19448 return 1;
19449 }
19450
19451
19452 static PyObject *_wrap_NullFont_get(void) {
19453 PyObject *pyobj;
19454
19455 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
19456 return pyobj;
19457 }
19458
19459
19460 static int _wrap_NullColour_set(PyObject *) {
19461 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
19462 return 1;
19463 }
19464
19465
19466 static PyObject *_wrap_NullColour_get(void) {
19467 PyObject *pyobj;
19468
19469 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
19470 return pyobj;
19471 }
19472
19473
19474 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
19475 PyObject *resultobj;
19476 wxPenList *arg1 = (wxPenList *) 0 ;
19477 wxPen *arg2 = (wxPen *) 0 ;
19478 PyObject * obj0 = 0 ;
19479 PyObject * obj1 = 0 ;
19480 char *kwnames[] = {
19481 (char *) "self",(char *) "pen", NULL
19482 };
19483
19484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
19485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19486 if (SWIG_arg_fail(1)) SWIG_fail;
19487 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19488 if (SWIG_arg_fail(2)) SWIG_fail;
19489 {
19490 PyThreadState* __tstate = wxPyBeginAllowThreads();
19491 (arg1)->AddPen(arg2);
19492
19493 wxPyEndAllowThreads(__tstate);
19494 if (PyErr_Occurred()) SWIG_fail;
19495 }
19496 Py_INCREF(Py_None); resultobj = Py_None;
19497 return resultobj;
19498 fail:
19499 return NULL;
19500 }
19501
19502
19503 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
19504 PyObject *resultobj;
19505 wxPenList *arg1 = (wxPenList *) 0 ;
19506 wxColour *arg2 = 0 ;
19507 int arg3 ;
19508 int arg4 ;
19509 wxPen *result;
19510 wxColour temp2 ;
19511 PyObject * obj0 = 0 ;
19512 PyObject * obj1 = 0 ;
19513 PyObject * obj2 = 0 ;
19514 PyObject * obj3 = 0 ;
19515 char *kwnames[] = {
19516 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
19517 };
19518
19519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19521 if (SWIG_arg_fail(1)) SWIG_fail;
19522 {
19523 arg2 = &temp2;
19524 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19525 }
19526 {
19527 arg3 = (int)(SWIG_As_int(obj2));
19528 if (SWIG_arg_fail(3)) SWIG_fail;
19529 }
19530 {
19531 arg4 = (int)(SWIG_As_int(obj3));
19532 if (SWIG_arg_fail(4)) SWIG_fail;
19533 }
19534 {
19535 PyThreadState* __tstate = wxPyBeginAllowThreads();
19536 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
19537
19538 wxPyEndAllowThreads(__tstate);
19539 if (PyErr_Occurred()) SWIG_fail;
19540 }
19541 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
19542 return resultobj;
19543 fail:
19544 return NULL;
19545 }
19546
19547
19548 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
19549 PyObject *resultobj;
19550 wxPenList *arg1 = (wxPenList *) 0 ;
19551 wxPen *arg2 = (wxPen *) 0 ;
19552 PyObject * obj0 = 0 ;
19553 PyObject * obj1 = 0 ;
19554 char *kwnames[] = {
19555 (char *) "self",(char *) "pen", NULL
19556 };
19557
19558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
19559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19560 if (SWIG_arg_fail(1)) SWIG_fail;
19561 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19562 if (SWIG_arg_fail(2)) SWIG_fail;
19563 {
19564 PyThreadState* __tstate = wxPyBeginAllowThreads();
19565 (arg1)->RemovePen(arg2);
19566
19567 wxPyEndAllowThreads(__tstate);
19568 if (PyErr_Occurred()) SWIG_fail;
19569 }
19570 Py_INCREF(Py_None); resultobj = Py_None;
19571 return resultobj;
19572 fail:
19573 return NULL;
19574 }
19575
19576
19577 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19578 PyObject *resultobj;
19579 wxPenList *arg1 = (wxPenList *) 0 ;
19580 int result;
19581 PyObject * obj0 = 0 ;
19582 char *kwnames[] = {
19583 (char *) "self", NULL
19584 };
19585
19586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
19587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19588 if (SWIG_arg_fail(1)) SWIG_fail;
19589 {
19590 PyThreadState* __tstate = wxPyBeginAllowThreads();
19591 result = (int)(arg1)->GetCount();
19592
19593 wxPyEndAllowThreads(__tstate);
19594 if (PyErr_Occurred()) SWIG_fail;
19595 }
19596 {
19597 resultobj = SWIG_From_int((int)(result));
19598 }
19599 return resultobj;
19600 fail:
19601 return NULL;
19602 }
19603
19604
19605 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
19606 PyObject *obj;
19607 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19608 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
19609 Py_INCREF(obj);
19610 return Py_BuildValue((char *)"");
19611 }
19612 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19613 PyObject *resultobj;
19614 wxBrushList *arg1 = (wxBrushList *) 0 ;
19615 wxBrush *arg2 = (wxBrush *) 0 ;
19616 PyObject * obj0 = 0 ;
19617 PyObject * obj1 = 0 ;
19618 char *kwnames[] = {
19619 (char *) "self",(char *) "brush", NULL
19620 };
19621
19622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
19623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19624 if (SWIG_arg_fail(1)) SWIG_fail;
19625 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19626 if (SWIG_arg_fail(2)) SWIG_fail;
19627 {
19628 PyThreadState* __tstate = wxPyBeginAllowThreads();
19629 (arg1)->AddBrush(arg2);
19630
19631 wxPyEndAllowThreads(__tstate);
19632 if (PyErr_Occurred()) SWIG_fail;
19633 }
19634 Py_INCREF(Py_None); resultobj = Py_None;
19635 return resultobj;
19636 fail:
19637 return NULL;
19638 }
19639
19640
19641 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19642 PyObject *resultobj;
19643 wxBrushList *arg1 = (wxBrushList *) 0 ;
19644 wxColour *arg2 = 0 ;
19645 int arg3 = (int) wxSOLID ;
19646 wxBrush *result;
19647 wxColour temp2 ;
19648 PyObject * obj0 = 0 ;
19649 PyObject * obj1 = 0 ;
19650 PyObject * obj2 = 0 ;
19651 char *kwnames[] = {
19652 (char *) "self",(char *) "colour",(char *) "style", NULL
19653 };
19654
19655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
19656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19657 if (SWIG_arg_fail(1)) SWIG_fail;
19658 {
19659 arg2 = &temp2;
19660 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19661 }
19662 if (obj2) {
19663 {
19664 arg3 = (int)(SWIG_As_int(obj2));
19665 if (SWIG_arg_fail(3)) SWIG_fail;
19666 }
19667 }
19668 {
19669 PyThreadState* __tstate = wxPyBeginAllowThreads();
19670 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
19671
19672 wxPyEndAllowThreads(__tstate);
19673 if (PyErr_Occurred()) SWIG_fail;
19674 }
19675 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
19676 return resultobj;
19677 fail:
19678 return NULL;
19679 }
19680
19681
19682 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19683 PyObject *resultobj;
19684 wxBrushList *arg1 = (wxBrushList *) 0 ;
19685 wxBrush *arg2 = (wxBrush *) 0 ;
19686 PyObject * obj0 = 0 ;
19687 PyObject * obj1 = 0 ;
19688 char *kwnames[] = {
19689 (char *) "self",(char *) "brush", NULL
19690 };
19691
19692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
19693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19694 if (SWIG_arg_fail(1)) SWIG_fail;
19695 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19696 if (SWIG_arg_fail(2)) SWIG_fail;
19697 {
19698 PyThreadState* __tstate = wxPyBeginAllowThreads();
19699 (arg1)->RemoveBrush(arg2);
19700
19701 wxPyEndAllowThreads(__tstate);
19702 if (PyErr_Occurred()) SWIG_fail;
19703 }
19704 Py_INCREF(Py_None); resultobj = Py_None;
19705 return resultobj;
19706 fail:
19707 return NULL;
19708 }
19709
19710
19711 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19712 PyObject *resultobj;
19713 wxBrushList *arg1 = (wxBrushList *) 0 ;
19714 int result;
19715 PyObject * obj0 = 0 ;
19716 char *kwnames[] = {
19717 (char *) "self", NULL
19718 };
19719
19720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
19721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19722 if (SWIG_arg_fail(1)) SWIG_fail;
19723 {
19724 PyThreadState* __tstate = wxPyBeginAllowThreads();
19725 result = (int)(arg1)->GetCount();
19726
19727 wxPyEndAllowThreads(__tstate);
19728 if (PyErr_Occurred()) SWIG_fail;
19729 }
19730 {
19731 resultobj = SWIG_From_int((int)(result));
19732 }
19733 return resultobj;
19734 fail:
19735 return NULL;
19736 }
19737
19738
19739 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
19740 PyObject *obj;
19741 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19742 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
19743 Py_INCREF(obj);
19744 return Py_BuildValue((char *)"");
19745 }
19746 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19747 PyObject *resultobj;
19748 wxColourDatabase *result;
19749 char *kwnames[] = {
19750 NULL
19751 };
19752
19753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
19754 {
19755 if (!wxPyCheckForApp()) SWIG_fail;
19756 PyThreadState* __tstate = wxPyBeginAllowThreads();
19757 result = (wxColourDatabase *)new wxColourDatabase();
19758
19759 wxPyEndAllowThreads(__tstate);
19760 if (PyErr_Occurred()) SWIG_fail;
19761 }
19762 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
19763 return resultobj;
19764 fail:
19765 return NULL;
19766 }
19767
19768
19769 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19770 PyObject *resultobj;
19771 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19772 PyObject * obj0 = 0 ;
19773 char *kwnames[] = {
19774 (char *) "self", NULL
19775 };
19776
19777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
19778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19779 if (SWIG_arg_fail(1)) SWIG_fail;
19780 {
19781 PyThreadState* __tstate = wxPyBeginAllowThreads();
19782 delete arg1;
19783
19784 wxPyEndAllowThreads(__tstate);
19785 if (PyErr_Occurred()) SWIG_fail;
19786 }
19787 Py_INCREF(Py_None); resultobj = Py_None;
19788 return resultobj;
19789 fail:
19790 return NULL;
19791 }
19792
19793
19794 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
19795 PyObject *resultobj;
19796 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19797 wxString *arg2 = 0 ;
19798 wxColour result;
19799 bool temp2 = false ;
19800 PyObject * obj0 = 0 ;
19801 PyObject * obj1 = 0 ;
19802 char *kwnames[] = {
19803 (char *) "self",(char *) "name", NULL
19804 };
19805
19806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
19807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19808 if (SWIG_arg_fail(1)) SWIG_fail;
19809 {
19810 arg2 = wxString_in_helper(obj1);
19811 if (arg2 == NULL) SWIG_fail;
19812 temp2 = true;
19813 }
19814 {
19815 PyThreadState* __tstate = wxPyBeginAllowThreads();
19816 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
19817
19818 wxPyEndAllowThreads(__tstate);
19819 if (PyErr_Occurred()) SWIG_fail;
19820 }
19821 {
19822 wxColour * resultptr;
19823 resultptr = new wxColour((wxColour &)(result));
19824 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19825 }
19826 {
19827 if (temp2)
19828 delete arg2;
19829 }
19830 return resultobj;
19831 fail:
19832 {
19833 if (temp2)
19834 delete arg2;
19835 }
19836 return NULL;
19837 }
19838
19839
19840 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
19841 PyObject *resultobj;
19842 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19843 wxColour *arg2 = 0 ;
19844 wxString result;
19845 wxColour temp2 ;
19846 PyObject * obj0 = 0 ;
19847 PyObject * obj1 = 0 ;
19848 char *kwnames[] = {
19849 (char *) "self",(char *) "colour", NULL
19850 };
19851
19852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
19853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19854 if (SWIG_arg_fail(1)) SWIG_fail;
19855 {
19856 arg2 = &temp2;
19857 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19858 }
19859 {
19860 PyThreadState* __tstate = wxPyBeginAllowThreads();
19861 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
19862
19863 wxPyEndAllowThreads(__tstate);
19864 if (PyErr_Occurred()) SWIG_fail;
19865 }
19866 {
19867 #if wxUSE_UNICODE
19868 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19869 #else
19870 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19871 #endif
19872 }
19873 return resultobj;
19874 fail:
19875 return NULL;
19876 }
19877
19878
19879 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
19880 PyObject *resultobj;
19881 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19882 wxString *arg2 = 0 ;
19883 wxColour *arg3 = 0 ;
19884 bool temp2 = false ;
19885 wxColour temp3 ;
19886 PyObject * obj0 = 0 ;
19887 PyObject * obj1 = 0 ;
19888 PyObject * obj2 = 0 ;
19889 char *kwnames[] = {
19890 (char *) "self",(char *) "name",(char *) "colour", NULL
19891 };
19892
19893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
19894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19895 if (SWIG_arg_fail(1)) SWIG_fail;
19896 {
19897 arg2 = wxString_in_helper(obj1);
19898 if (arg2 == NULL) SWIG_fail;
19899 temp2 = true;
19900 }
19901 {
19902 arg3 = &temp3;
19903 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19904 }
19905 {
19906 PyThreadState* __tstate = wxPyBeginAllowThreads();
19907 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
19908
19909 wxPyEndAllowThreads(__tstate);
19910 if (PyErr_Occurred()) SWIG_fail;
19911 }
19912 Py_INCREF(Py_None); resultobj = Py_None;
19913 {
19914 if (temp2)
19915 delete arg2;
19916 }
19917 return resultobj;
19918 fail:
19919 {
19920 if (temp2)
19921 delete arg2;
19922 }
19923 return NULL;
19924 }
19925
19926
19927 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
19928 PyObject *resultobj;
19929 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19930 wxString *arg2 = 0 ;
19931 int arg3 ;
19932 int arg4 ;
19933 int arg5 ;
19934 bool temp2 = false ;
19935 PyObject * obj0 = 0 ;
19936 PyObject * obj1 = 0 ;
19937 PyObject * obj2 = 0 ;
19938 PyObject * obj3 = 0 ;
19939 PyObject * obj4 = 0 ;
19940 char *kwnames[] = {
19941 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
19942 };
19943
19944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19946 if (SWIG_arg_fail(1)) SWIG_fail;
19947 {
19948 arg2 = wxString_in_helper(obj1);
19949 if (arg2 == NULL) SWIG_fail;
19950 temp2 = true;
19951 }
19952 {
19953 arg3 = (int)(SWIG_As_int(obj2));
19954 if (SWIG_arg_fail(3)) SWIG_fail;
19955 }
19956 {
19957 arg4 = (int)(SWIG_As_int(obj3));
19958 if (SWIG_arg_fail(4)) SWIG_fail;
19959 }
19960 {
19961 arg5 = (int)(SWIG_As_int(obj4));
19962 if (SWIG_arg_fail(5)) SWIG_fail;
19963 }
19964 {
19965 PyThreadState* __tstate = wxPyBeginAllowThreads();
19966 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
19967
19968 wxPyEndAllowThreads(__tstate);
19969 if (PyErr_Occurred()) SWIG_fail;
19970 }
19971 Py_INCREF(Py_None); resultobj = Py_None;
19972 {
19973 if (temp2)
19974 delete arg2;
19975 }
19976 return resultobj;
19977 fail:
19978 {
19979 if (temp2)
19980 delete arg2;
19981 }
19982 return NULL;
19983 }
19984
19985
19986 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
19987 PyObject *obj;
19988 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19989 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
19990 Py_INCREF(obj);
19991 return Py_BuildValue((char *)"");
19992 }
19993 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
19994 PyObject *resultobj;
19995 wxFontList *arg1 = (wxFontList *) 0 ;
19996 wxFont *arg2 = (wxFont *) 0 ;
19997 PyObject * obj0 = 0 ;
19998 PyObject * obj1 = 0 ;
19999 char *kwnames[] = {
20000 (char *) "self",(char *) "font", NULL
20001 };
20002
20003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
20004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20005 if (SWIG_arg_fail(1)) SWIG_fail;
20006 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20007 if (SWIG_arg_fail(2)) SWIG_fail;
20008 {
20009 PyThreadState* __tstate = wxPyBeginAllowThreads();
20010 (arg1)->AddFont(arg2);
20011
20012 wxPyEndAllowThreads(__tstate);
20013 if (PyErr_Occurred()) SWIG_fail;
20014 }
20015 Py_INCREF(Py_None); resultobj = Py_None;
20016 return resultobj;
20017 fail:
20018 return NULL;
20019 }
20020
20021
20022 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
20023 PyObject *resultobj;
20024 wxFontList *arg1 = (wxFontList *) 0 ;
20025 int arg2 ;
20026 int arg3 ;
20027 int arg4 ;
20028 int arg5 ;
20029 bool arg6 = (bool) false ;
20030 wxString const &arg7_defvalue = wxPyEmptyString ;
20031 wxString *arg7 = (wxString *) &arg7_defvalue ;
20032 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
20033 wxFont *result;
20034 bool temp7 = false ;
20035 PyObject * obj0 = 0 ;
20036 PyObject * obj1 = 0 ;
20037 PyObject * obj2 = 0 ;
20038 PyObject * obj3 = 0 ;
20039 PyObject * obj4 = 0 ;
20040 PyObject * obj5 = 0 ;
20041 PyObject * obj6 = 0 ;
20042 PyObject * obj7 = 0 ;
20043 char *kwnames[] = {
20044 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
20045 };
20046
20047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20049 if (SWIG_arg_fail(1)) SWIG_fail;
20050 {
20051 arg2 = (int)(SWIG_As_int(obj1));
20052 if (SWIG_arg_fail(2)) SWIG_fail;
20053 }
20054 {
20055 arg3 = (int)(SWIG_As_int(obj2));
20056 if (SWIG_arg_fail(3)) SWIG_fail;
20057 }
20058 {
20059 arg4 = (int)(SWIG_As_int(obj3));
20060 if (SWIG_arg_fail(4)) SWIG_fail;
20061 }
20062 {
20063 arg5 = (int)(SWIG_As_int(obj4));
20064 if (SWIG_arg_fail(5)) SWIG_fail;
20065 }
20066 if (obj5) {
20067 {
20068 arg6 = (bool)(SWIG_As_bool(obj5));
20069 if (SWIG_arg_fail(6)) SWIG_fail;
20070 }
20071 }
20072 if (obj6) {
20073 {
20074 arg7 = wxString_in_helper(obj6);
20075 if (arg7 == NULL) SWIG_fail;
20076 temp7 = true;
20077 }
20078 }
20079 if (obj7) {
20080 {
20081 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
20082 if (SWIG_arg_fail(8)) SWIG_fail;
20083 }
20084 }
20085 {
20086 PyThreadState* __tstate = wxPyBeginAllowThreads();
20087 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
20088
20089 wxPyEndAllowThreads(__tstate);
20090 if (PyErr_Occurred()) SWIG_fail;
20091 }
20092 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
20093 {
20094 if (temp7)
20095 delete arg7;
20096 }
20097 return resultobj;
20098 fail:
20099 {
20100 if (temp7)
20101 delete arg7;
20102 }
20103 return NULL;
20104 }
20105
20106
20107 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
20108 PyObject *resultobj;
20109 wxFontList *arg1 = (wxFontList *) 0 ;
20110 wxFont *arg2 = (wxFont *) 0 ;
20111 PyObject * obj0 = 0 ;
20112 PyObject * obj1 = 0 ;
20113 char *kwnames[] = {
20114 (char *) "self",(char *) "font", NULL
20115 };
20116
20117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
20118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20119 if (SWIG_arg_fail(1)) SWIG_fail;
20120 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20121 if (SWIG_arg_fail(2)) SWIG_fail;
20122 {
20123 PyThreadState* __tstate = wxPyBeginAllowThreads();
20124 (arg1)->RemoveFont(arg2);
20125
20126 wxPyEndAllowThreads(__tstate);
20127 if (PyErr_Occurred()) SWIG_fail;
20128 }
20129 Py_INCREF(Py_None); resultobj = Py_None;
20130 return resultobj;
20131 fail:
20132 return NULL;
20133 }
20134
20135
20136 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20137 PyObject *resultobj;
20138 wxFontList *arg1 = (wxFontList *) 0 ;
20139 int result;
20140 PyObject * obj0 = 0 ;
20141 char *kwnames[] = {
20142 (char *) "self", NULL
20143 };
20144
20145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
20146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20147 if (SWIG_arg_fail(1)) SWIG_fail;
20148 {
20149 PyThreadState* __tstate = wxPyBeginAllowThreads();
20150 result = (int)(arg1)->GetCount();
20151
20152 wxPyEndAllowThreads(__tstate);
20153 if (PyErr_Occurred()) SWIG_fail;
20154 }
20155 {
20156 resultobj = SWIG_From_int((int)(result));
20157 }
20158 return resultobj;
20159 fail:
20160 return NULL;
20161 }
20162
20163
20164 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
20165 PyObject *obj;
20166 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20167 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
20168 Py_INCREF(obj);
20169 return Py_BuildValue((char *)"");
20170 }
20171 static int _wrap_TheFontList_set(PyObject *) {
20172 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
20173 return 1;
20174 }
20175
20176
20177 static PyObject *_wrap_TheFontList_get(void) {
20178 PyObject *pyobj;
20179
20180 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
20181 return pyobj;
20182 }
20183
20184
20185 static int _wrap_ThePenList_set(PyObject *) {
20186 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
20187 return 1;
20188 }
20189
20190
20191 static PyObject *_wrap_ThePenList_get(void) {
20192 PyObject *pyobj;
20193
20194 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
20195 return pyobj;
20196 }
20197
20198
20199 static int _wrap_TheBrushList_set(PyObject *) {
20200 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
20201 return 1;
20202 }
20203
20204
20205 static PyObject *_wrap_TheBrushList_get(void) {
20206 PyObject *pyobj;
20207
20208 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
20209 return pyobj;
20210 }
20211
20212
20213 static int _wrap_TheColourDatabase_set(PyObject *) {
20214 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
20215 return 1;
20216 }
20217
20218
20219 static PyObject *_wrap_TheColourDatabase_get(void) {
20220 PyObject *pyobj;
20221
20222 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
20223 return pyobj;
20224 }
20225
20226
20227 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
20228 PyObject *resultobj;
20229 wxEffects *result;
20230 char *kwnames[] = {
20231 NULL
20232 };
20233
20234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
20235 {
20236 PyThreadState* __tstate = wxPyBeginAllowThreads();
20237 result = (wxEffects *)new wxEffects();
20238
20239 wxPyEndAllowThreads(__tstate);
20240 if (PyErr_Occurred()) SWIG_fail;
20241 }
20242 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
20243 return resultobj;
20244 fail:
20245 return NULL;
20246 }
20247
20248
20249 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20250 PyObject *resultobj;
20251 wxEffects *arg1 = (wxEffects *) 0 ;
20252 wxColour result;
20253 PyObject * obj0 = 0 ;
20254 char *kwnames[] = {
20255 (char *) "self", NULL
20256 };
20257
20258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
20259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20260 if (SWIG_arg_fail(1)) SWIG_fail;
20261 {
20262 PyThreadState* __tstate = wxPyBeginAllowThreads();
20263 result = ((wxEffects const *)arg1)->GetHighlightColour();
20264
20265 wxPyEndAllowThreads(__tstate);
20266 if (PyErr_Occurred()) SWIG_fail;
20267 }
20268 {
20269 wxColour * resultptr;
20270 resultptr = new wxColour((wxColour &)(result));
20271 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20272 }
20273 return resultobj;
20274 fail:
20275 return NULL;
20276 }
20277
20278
20279 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20280 PyObject *resultobj;
20281 wxEffects *arg1 = (wxEffects *) 0 ;
20282 wxColour result;
20283 PyObject * obj0 = 0 ;
20284 char *kwnames[] = {
20285 (char *) "self", NULL
20286 };
20287
20288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
20289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20290 if (SWIG_arg_fail(1)) SWIG_fail;
20291 {
20292 PyThreadState* __tstate = wxPyBeginAllowThreads();
20293 result = ((wxEffects const *)arg1)->GetLightShadow();
20294
20295 wxPyEndAllowThreads(__tstate);
20296 if (PyErr_Occurred()) SWIG_fail;
20297 }
20298 {
20299 wxColour * resultptr;
20300 resultptr = new wxColour((wxColour &)(result));
20301 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20302 }
20303 return resultobj;
20304 fail:
20305 return NULL;
20306 }
20307
20308
20309 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20310 PyObject *resultobj;
20311 wxEffects *arg1 = (wxEffects *) 0 ;
20312 wxColour result;
20313 PyObject * obj0 = 0 ;
20314 char *kwnames[] = {
20315 (char *) "self", NULL
20316 };
20317
20318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
20319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20320 if (SWIG_arg_fail(1)) SWIG_fail;
20321 {
20322 PyThreadState* __tstate = wxPyBeginAllowThreads();
20323 result = ((wxEffects const *)arg1)->GetFaceColour();
20324
20325 wxPyEndAllowThreads(__tstate);
20326 if (PyErr_Occurred()) SWIG_fail;
20327 }
20328 {
20329 wxColour * resultptr;
20330 resultptr = new wxColour((wxColour &)(result));
20331 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20332 }
20333 return resultobj;
20334 fail:
20335 return NULL;
20336 }
20337
20338
20339 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20340 PyObject *resultobj;
20341 wxEffects *arg1 = (wxEffects *) 0 ;
20342 wxColour result;
20343 PyObject * obj0 = 0 ;
20344 char *kwnames[] = {
20345 (char *) "self", NULL
20346 };
20347
20348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
20349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20350 if (SWIG_arg_fail(1)) SWIG_fail;
20351 {
20352 PyThreadState* __tstate = wxPyBeginAllowThreads();
20353 result = ((wxEffects const *)arg1)->GetMediumShadow();
20354
20355 wxPyEndAllowThreads(__tstate);
20356 if (PyErr_Occurred()) SWIG_fail;
20357 }
20358 {
20359 wxColour * resultptr;
20360 resultptr = new wxColour((wxColour &)(result));
20361 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20362 }
20363 return resultobj;
20364 fail:
20365 return NULL;
20366 }
20367
20368
20369 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20370 PyObject *resultobj;
20371 wxEffects *arg1 = (wxEffects *) 0 ;
20372 wxColour result;
20373 PyObject * obj0 = 0 ;
20374 char *kwnames[] = {
20375 (char *) "self", NULL
20376 };
20377
20378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
20379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20380 if (SWIG_arg_fail(1)) SWIG_fail;
20381 {
20382 PyThreadState* __tstate = wxPyBeginAllowThreads();
20383 result = ((wxEffects const *)arg1)->GetDarkShadow();
20384
20385 wxPyEndAllowThreads(__tstate);
20386 if (PyErr_Occurred()) SWIG_fail;
20387 }
20388 {
20389 wxColour * resultptr;
20390 resultptr = new wxColour((wxColour &)(result));
20391 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20392 }
20393 return resultobj;
20394 fail:
20395 return NULL;
20396 }
20397
20398
20399 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20400 PyObject *resultobj;
20401 wxEffects *arg1 = (wxEffects *) 0 ;
20402 wxColour *arg2 = 0 ;
20403 wxColour temp2 ;
20404 PyObject * obj0 = 0 ;
20405 PyObject * obj1 = 0 ;
20406 char *kwnames[] = {
20407 (char *) "self",(char *) "c", NULL
20408 };
20409
20410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
20411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20412 if (SWIG_arg_fail(1)) SWIG_fail;
20413 {
20414 arg2 = &temp2;
20415 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20416 }
20417 {
20418 PyThreadState* __tstate = wxPyBeginAllowThreads();
20419 (arg1)->SetHighlightColour((wxColour const &)*arg2);
20420
20421 wxPyEndAllowThreads(__tstate);
20422 if (PyErr_Occurred()) SWIG_fail;
20423 }
20424 Py_INCREF(Py_None); resultobj = Py_None;
20425 return resultobj;
20426 fail:
20427 return NULL;
20428 }
20429
20430
20431 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20432 PyObject *resultobj;
20433 wxEffects *arg1 = (wxEffects *) 0 ;
20434 wxColour *arg2 = 0 ;
20435 wxColour temp2 ;
20436 PyObject * obj0 = 0 ;
20437 PyObject * obj1 = 0 ;
20438 char *kwnames[] = {
20439 (char *) "self",(char *) "c", NULL
20440 };
20441
20442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
20443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20444 if (SWIG_arg_fail(1)) SWIG_fail;
20445 {
20446 arg2 = &temp2;
20447 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20448 }
20449 {
20450 PyThreadState* __tstate = wxPyBeginAllowThreads();
20451 (arg1)->SetLightShadow((wxColour const &)*arg2);
20452
20453 wxPyEndAllowThreads(__tstate);
20454 if (PyErr_Occurred()) SWIG_fail;
20455 }
20456 Py_INCREF(Py_None); resultobj = Py_None;
20457 return resultobj;
20458 fail:
20459 return NULL;
20460 }
20461
20462
20463 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20464 PyObject *resultobj;
20465 wxEffects *arg1 = (wxEffects *) 0 ;
20466 wxColour *arg2 = 0 ;
20467 wxColour temp2 ;
20468 PyObject * obj0 = 0 ;
20469 PyObject * obj1 = 0 ;
20470 char *kwnames[] = {
20471 (char *) "self",(char *) "c", NULL
20472 };
20473
20474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
20475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20476 if (SWIG_arg_fail(1)) SWIG_fail;
20477 {
20478 arg2 = &temp2;
20479 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20480 }
20481 {
20482 PyThreadState* __tstate = wxPyBeginAllowThreads();
20483 (arg1)->SetFaceColour((wxColour const &)*arg2);
20484
20485 wxPyEndAllowThreads(__tstate);
20486 if (PyErr_Occurred()) SWIG_fail;
20487 }
20488 Py_INCREF(Py_None); resultobj = Py_None;
20489 return resultobj;
20490 fail:
20491 return NULL;
20492 }
20493
20494
20495 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20496 PyObject *resultobj;
20497 wxEffects *arg1 = (wxEffects *) 0 ;
20498 wxColour *arg2 = 0 ;
20499 wxColour temp2 ;
20500 PyObject * obj0 = 0 ;
20501 PyObject * obj1 = 0 ;
20502 char *kwnames[] = {
20503 (char *) "self",(char *) "c", NULL
20504 };
20505
20506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
20507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20508 if (SWIG_arg_fail(1)) SWIG_fail;
20509 {
20510 arg2 = &temp2;
20511 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20512 }
20513 {
20514 PyThreadState* __tstate = wxPyBeginAllowThreads();
20515 (arg1)->SetMediumShadow((wxColour const &)*arg2);
20516
20517 wxPyEndAllowThreads(__tstate);
20518 if (PyErr_Occurred()) SWIG_fail;
20519 }
20520 Py_INCREF(Py_None); resultobj = Py_None;
20521 return resultobj;
20522 fail:
20523 return NULL;
20524 }
20525
20526
20527 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20528 PyObject *resultobj;
20529 wxEffects *arg1 = (wxEffects *) 0 ;
20530 wxColour *arg2 = 0 ;
20531 wxColour temp2 ;
20532 PyObject * obj0 = 0 ;
20533 PyObject * obj1 = 0 ;
20534 char *kwnames[] = {
20535 (char *) "self",(char *) "c", NULL
20536 };
20537
20538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
20539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20540 if (SWIG_arg_fail(1)) SWIG_fail;
20541 {
20542 arg2 = &temp2;
20543 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20544 }
20545 {
20546 PyThreadState* __tstate = wxPyBeginAllowThreads();
20547 (arg1)->SetDarkShadow((wxColour const &)*arg2);
20548
20549 wxPyEndAllowThreads(__tstate);
20550 if (PyErr_Occurred()) SWIG_fail;
20551 }
20552 Py_INCREF(Py_None); resultobj = Py_None;
20553 return resultobj;
20554 fail:
20555 return NULL;
20556 }
20557
20558
20559 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20560 PyObject *resultobj;
20561 wxEffects *arg1 = (wxEffects *) 0 ;
20562 wxColour *arg2 = 0 ;
20563 wxColour *arg3 = 0 ;
20564 wxColour *arg4 = 0 ;
20565 wxColour *arg5 = 0 ;
20566 wxColour *arg6 = 0 ;
20567 wxColour temp2 ;
20568 wxColour temp3 ;
20569 wxColour temp4 ;
20570 wxColour temp5 ;
20571 wxColour temp6 ;
20572 PyObject * obj0 = 0 ;
20573 PyObject * obj1 = 0 ;
20574 PyObject * obj2 = 0 ;
20575 PyObject * obj3 = 0 ;
20576 PyObject * obj4 = 0 ;
20577 PyObject * obj5 = 0 ;
20578 char *kwnames[] = {
20579 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
20580 };
20581
20582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
20583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20584 if (SWIG_arg_fail(1)) SWIG_fail;
20585 {
20586 arg2 = &temp2;
20587 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20588 }
20589 {
20590 arg3 = &temp3;
20591 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20592 }
20593 {
20594 arg4 = &temp4;
20595 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
20596 }
20597 {
20598 arg5 = &temp5;
20599 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
20600 }
20601 {
20602 arg6 = &temp6;
20603 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
20604 }
20605 {
20606 PyThreadState* __tstate = wxPyBeginAllowThreads();
20607 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
20608
20609 wxPyEndAllowThreads(__tstate);
20610 if (PyErr_Occurred()) SWIG_fail;
20611 }
20612 Py_INCREF(Py_None); resultobj = Py_None;
20613 return resultobj;
20614 fail:
20615 return NULL;
20616 }
20617
20618
20619 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
20620 PyObject *resultobj;
20621 wxEffects *arg1 = (wxEffects *) 0 ;
20622 wxDC *arg2 = 0 ;
20623 wxRect *arg3 = 0 ;
20624 int arg4 = (int) 1 ;
20625 wxRect temp3 ;
20626 PyObject * obj0 = 0 ;
20627 PyObject * obj1 = 0 ;
20628 PyObject * obj2 = 0 ;
20629 PyObject * obj3 = 0 ;
20630 char *kwnames[] = {
20631 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
20632 };
20633
20634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20636 if (SWIG_arg_fail(1)) SWIG_fail;
20637 {
20638 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20639 if (SWIG_arg_fail(2)) SWIG_fail;
20640 if (arg2 == NULL) {
20641 SWIG_null_ref("wxDC");
20642 }
20643 if (SWIG_arg_fail(2)) SWIG_fail;
20644 }
20645 {
20646 arg3 = &temp3;
20647 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
20648 }
20649 if (obj3) {
20650 {
20651 arg4 = (int)(SWIG_As_int(obj3));
20652 if (SWIG_arg_fail(4)) SWIG_fail;
20653 }
20654 }
20655 {
20656 PyThreadState* __tstate = wxPyBeginAllowThreads();
20657 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
20658
20659 wxPyEndAllowThreads(__tstate);
20660 if (PyErr_Occurred()) SWIG_fail;
20661 }
20662 Py_INCREF(Py_None); resultobj = Py_None;
20663 return resultobj;
20664 fail:
20665 return NULL;
20666 }
20667
20668
20669 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
20670 PyObject *resultobj;
20671 wxEffects *arg1 = (wxEffects *) 0 ;
20672 wxRect *arg2 = 0 ;
20673 wxDC *arg3 = 0 ;
20674 wxBitmap *arg4 = 0 ;
20675 bool result;
20676 wxRect temp2 ;
20677 PyObject * obj0 = 0 ;
20678 PyObject * obj1 = 0 ;
20679 PyObject * obj2 = 0 ;
20680 PyObject * obj3 = 0 ;
20681 char *kwnames[] = {
20682 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
20683 };
20684
20685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20687 if (SWIG_arg_fail(1)) SWIG_fail;
20688 {
20689 arg2 = &temp2;
20690 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20691 }
20692 {
20693 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20694 if (SWIG_arg_fail(3)) SWIG_fail;
20695 if (arg3 == NULL) {
20696 SWIG_null_ref("wxDC");
20697 }
20698 if (SWIG_arg_fail(3)) SWIG_fail;
20699 }
20700 {
20701 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
20702 if (SWIG_arg_fail(4)) SWIG_fail;
20703 if (arg4 == NULL) {
20704 SWIG_null_ref("wxBitmap");
20705 }
20706 if (SWIG_arg_fail(4)) SWIG_fail;
20707 }
20708 {
20709 PyThreadState* __tstate = wxPyBeginAllowThreads();
20710 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
20711
20712 wxPyEndAllowThreads(__tstate);
20713 if (PyErr_Occurred()) SWIG_fail;
20714 }
20715 {
20716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20717 }
20718 return resultobj;
20719 fail:
20720 return NULL;
20721 }
20722
20723
20724 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
20725 PyObject *obj;
20726 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20727 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
20728 Py_INCREF(obj);
20729 return Py_BuildValue((char *)"");
20730 }
20731 static PyMethodDef SwigMethods[] = {
20732 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20733 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20734 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20735 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20736 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
20737 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
20738 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20739 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
20740 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20741 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20742 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
20743 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
20744 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
20745 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20746 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20747 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20748 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20749 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20750 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20751 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20752 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20753 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20754 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
20755 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20756 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20757 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20758 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20759 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
20760 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20761 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
20762 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20763 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20764 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20765 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20766 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20767 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20768 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20769 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20770 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20771 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20772 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20773 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20774 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20775 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20776 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20777 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20778 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20779 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20780 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
20781 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20782 { (char *)"new_BrushFromBitmap", (PyCFunction) _wrap_new_BrushFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20783 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20784 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20785 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20786 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20787 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20788 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20789 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20790 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
20791 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20792 { (char *)"Brush_MacGetTheme", (PyCFunction) _wrap_Brush_MacGetTheme, METH_VARARGS | METH_KEYWORDS, NULL},
20793 { (char *)"Brush_MacSetTheme", (PyCFunction) _wrap_Brush_MacSetTheme, METH_VARARGS | METH_KEYWORDS, NULL},
20794 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
20795 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20796 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20797 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20798 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20799 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20800 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20801 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
20802 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20803 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20804 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20805 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20806 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20807 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
20808 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20809 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20810 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
20811 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20812 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
20813 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
20814 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
20815 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20816 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20817 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20818 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20819 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20820 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20821 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20822 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
20823 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
20824 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
20825 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20826 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20827 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20828 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20829 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20830 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20831 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20832 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20833 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20834 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20835 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20836 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20837 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20838 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20839 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
20840 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20841 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20842 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20843 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20844 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20845 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20846 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20847 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
20848 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20849 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20850 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20851 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20852 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20853 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20854 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20855 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
20856 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20857 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20858 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20859 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20860 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20861 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
20862 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20863 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20864 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20865 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
20866 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20867 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
20868 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
20869 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
20870 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20871 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
20872 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
20873 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
20874 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
20875 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
20876 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20877 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
20878 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
20879 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
20880 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20881 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
20882 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
20883 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20884 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
20885 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
20886 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20887 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20888 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20889 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20890 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
20891 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20892 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20893 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
20894 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
20895 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
20896 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20897 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
20898 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20899 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
20900 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
20901 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
20902 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
20903 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
20904 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
20905 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20906 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20907 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
20908 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
20909 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20910 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20911 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20912 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20913 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20914 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20915 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20916 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20917 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20918 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20919 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20920 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20921 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20922 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20923 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20924 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20925 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
20926 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20927 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20928 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
20929 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
20930 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
20931 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
20932 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
20933 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20934 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20935 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20936 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20937 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
20938 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20939 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20940 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20941 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20942 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20943 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20944 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20945 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
20946 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20947 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
20948 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
20949 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20950 { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
20951 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20952 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20953 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20954 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
20955 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
20956 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
20957 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
20958 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20959 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20960 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20961 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
20962 { (char *)"new_Font2", (PyCFunction) _wrap_new_Font2, METH_VARARGS | METH_KEYWORDS, NULL},
20963 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20964 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20965 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20966 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20967 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20968 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20969 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
20970 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20971 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20972 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20973 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20974 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20975 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20976 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20977 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20978 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20979 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20980 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20981 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20982 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20983 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20984 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20985 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20986 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20987 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20988 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20989 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
20990 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20991 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
20992 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
20993 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
20994 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20995 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20996 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20997 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20998 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
20999 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21000 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21001 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21002 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21003 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21004 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21005 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21006 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
21007 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
21008 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
21009 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
21010 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
21011 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
21012 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
21013 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
21014 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21015 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21016 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
21017 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
21018 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21019 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21020 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21021 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21022 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21023 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21024 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
21025 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
21026 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
21027 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
21028 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
21029 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21030 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
21031 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21032 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21033 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
21034 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
21035 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
21036 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21037 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
21038 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21039 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21040 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21041 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
21042 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21043 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21044 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
21045 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
21046 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
21047 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21048 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21049 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
21050 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21051 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21052 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21053 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
21054 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21055 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
21056 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21057 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
21058 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21059 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
21060 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
21061 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
21062 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21063 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21064 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21065 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21066 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21067 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21068 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21069 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21070 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21071 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
21072 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21073 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
21074 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
21075 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21076 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21077 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21078 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21079 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21080 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
21081 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21082 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
21083 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21084 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
21085 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21086 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21087 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21088 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21089 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21090 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
21091 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
21092 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21093 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21094 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
21095 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21096 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21097 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21098 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
21099 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
21100 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21101 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21102 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21103 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21104 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21105 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21106 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21107 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21108 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21109 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21110 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21111 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21112 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21113 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21114 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
21115 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21116 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21117 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
21118 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21119 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
21120 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
21121 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21122 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21123 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
21124 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
21125 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21126 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21127 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21128 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21129 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21130 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
21131 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21132 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21133 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21134 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21135 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21136 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21137 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21138 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21139 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21140 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21141 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21142 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21143 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21144 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21145 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21146 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21147 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21148 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21149 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21150 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21151 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21152 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21153 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21154 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21155 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
21156 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21157 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21158 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21159 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21160 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21161 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21162 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
21163 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
21164 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
21165 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
21166 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21167 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
21168 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
21169 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
21170 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
21171 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
21172 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
21173 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
21174 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
21175 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
21176 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
21177 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
21178 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
21179 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
21180 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
21181 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
21182 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21183 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
21184 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
21185 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
21186 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21187 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21188 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
21189 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
21190 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
21191 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21192 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
21193 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
21194 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
21195 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
21196 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
21197 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
21198 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21199 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21200 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21201 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21202 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
21203 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21204 { (char *)"delete_MetaFile", (PyCFunction) _wrap_delete_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21205 { (char *)"MetaFile_Ok", (PyCFunction) _wrap_MetaFile_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21206 { (char *)"MetaFile_SetClipboard", (PyCFunction) _wrap_MetaFile_SetClipboard, METH_VARARGS | METH_KEYWORDS, NULL},
21207 { (char *)"MetaFile_GetSize", (PyCFunction) _wrap_MetaFile_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21208 { (char *)"MetaFile_GetWidth", (PyCFunction) _wrap_MetaFile_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21209 { (char *)"MetaFile_GetHeight", (PyCFunction) _wrap_MetaFile_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21210 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
21211 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
21212 { (char *)"MetaFileDC_Close", (PyCFunction) _wrap_MetaFileDC_Close, METH_VARARGS | METH_KEYWORDS, NULL},
21213 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
21214 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
21215 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
21216 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21217 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21218 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
21219 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
21220 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21221 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21222 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21223 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
21224 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
21225 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
21226 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
21227 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
21228 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21229 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
21230 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
21231 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
21232 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
21233 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21234 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
21235 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21236 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21237 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21238 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21239 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
21240 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21241 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21242 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
21243 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
21244 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
21245 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
21246 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
21247 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
21248 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
21249 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
21250 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21251 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
21252 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
21253 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21254 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21255 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21256 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21257 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21258 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21259 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21260 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21261 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21262 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21263 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21264 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
21265 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21266 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
21267 { NULL, NULL, 0, NULL }
21268 };
21269
21270
21271 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21272
21273 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
21274 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
21275 }
21276 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
21277 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
21278 }
21279 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
21280 return (void *)((wxGDIObject *) ((wxIcon *) x));
21281 }
21282 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
21283 return (void *)((wxGDIObject *) ((wxPalette *) x));
21284 }
21285 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
21286 return (void *)((wxGDIObject *) ((wxPen *) x));
21287 }
21288 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
21289 return (void *)((wxGDIObject *) ((wxFont *) x));
21290 }
21291 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
21292 return (void *)((wxGDIObject *) ((wxCursor *) x));
21293 }
21294 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
21295 return (void *)((wxGDIObject *) ((wxBitmap *) x));
21296 }
21297 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
21298 return (void *)((wxGDIObject *) ((wxRegion *) x));
21299 }
21300 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
21301 return (void *)((wxGDIObject *) ((wxBrush *) x));
21302 }
21303 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
21304 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
21305 }
21306 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
21307 return (void *)((wxDC *) ((wxScreenDC *) x));
21308 }
21309 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
21310 return (void *)((wxDC *) ((wxMirrorDC *) x));
21311 }
21312 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
21313 return (void *)((wxDC *) ((wxMemoryDC *) x));
21314 }
21315 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
21316 return (void *)((wxDC *) ((wxWindowDC *) x));
21317 }
21318 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
21319 return (void *)((wxDC *) ((wxMetaFileDC *) x));
21320 }
21321 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
21322 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21323 }
21324 static void *_p_wxClientDCTo_p_wxDC(void *x) {
21325 return (void *)((wxDC *) ((wxClientDC *) x));
21326 }
21327 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
21328 return (void *)((wxDC *) ((wxPaintDC *) x));
21329 }
21330 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
21331 return (void *)((wxDC *) ((wxPostScriptDC *) x));
21332 }
21333 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
21334 return (void *)((wxDC *) ((wxPrinterDC *) x));
21335 }
21336 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
21337 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
21338 }
21339 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21340 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21341 }
21342 static void *_p_wxPenTo_p_wxObject(void *x) {
21343 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
21344 }
21345 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
21346 return (void *)((wxObject *) ((wxRegionIterator *) x));
21347 }
21348 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21349 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21350 }
21351 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21352 return (void *)((wxObject *) ((wxSizerItem *) x));
21353 }
21354 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
21355 return (void *)((wxObject *) ((wxColourDatabase *) x));
21356 }
21357 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21358 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21359 }
21360 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21361 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21362 }
21363 static void *_p_wxIconTo_p_wxObject(void *x) {
21364 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
21365 }
21366 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21367 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21368 }
21369 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21370 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21371 }
21372 static void *_p_wxSizerTo_p_wxObject(void *x) {
21373 return (void *)((wxObject *) ((wxSizer *) x));
21374 }
21375 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21376 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21377 }
21378 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21379 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21380 }
21381 static void *_p_wxPenListTo_p_wxObject(void *x) {
21382 return (void *)((wxObject *) ((wxPenList *) x));
21383 }
21384 static void *_p_wxEventTo_p_wxObject(void *x) {
21385 return (void *)((wxObject *) ((wxEvent *) x));
21386 }
21387 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21388 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21389 }
21390 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21391 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21392 }
21393 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21394 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21395 }
21396 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21397 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21398 }
21399 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21400 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21401 }
21402 static void *_p_wxDCTo_p_wxObject(void *x) {
21403 return (void *)((wxObject *) ((wxDC *) x));
21404 }
21405 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21406 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21407 }
21408 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21409 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21410 }
21411 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21412 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21413 }
21414 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21415 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21416 }
21417 static void *_p_wxControlTo_p_wxObject(void *x) {
21418 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21419 }
21420 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21421 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21422 }
21423 static void *_p_wxClientDCTo_p_wxObject(void *x) {
21424 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
21425 }
21426 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21427 return (void *)((wxObject *) ((wxFSFile *) x));
21428 }
21429 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
21430 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
21431 }
21432 static void *_p_wxRegionTo_p_wxObject(void *x) {
21433 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
21434 }
21435 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21436 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21437 }
21438 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
21439 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
21440 }
21441 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
21442 return (void *)((wxObject *) ((wxGDIObject *) x));
21443 }
21444 static void *_p_wxEffectsTo_p_wxObject(void *x) {
21445 return (void *)((wxObject *) ((wxEffects *) x));
21446 }
21447 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21448 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21449 }
21450 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21451 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21452 }
21453 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
21454 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
21455 }
21456 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21457 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21458 }
21459 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21460 return (void *)((wxObject *) ((wxMenuItem *) x));
21461 }
21462 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21463 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21464 }
21465 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21466 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21467 }
21468 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21469 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21470 }
21471 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21472 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21473 }
21474 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21475 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21476 }
21477 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21478 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21479 }
21480 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21481 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21482 }
21483 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21484 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21485 }
21486 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21487 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21488 }
21489 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21490 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21491 }
21492 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21493 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21494 }
21495 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21496 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21497 }
21498 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21499 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21500 }
21501 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21502 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21503 }
21504 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21505 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21506 }
21507 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21508 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21509 }
21510 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21511 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21512 }
21513 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21514 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21515 }
21516 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21517 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21518 }
21519 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21520 return (void *)((wxObject *) ((wxImageHandler *) x));
21521 }
21522 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21523 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21524 }
21525 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21526 return (void *)((wxObject *) ((wxEvtHandler *) x));
21527 }
21528 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
21529 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21530 }
21531 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
21532 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
21533 }
21534 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
21535 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
21536 }
21537 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
21538 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
21539 }
21540 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21541 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21542 }
21543 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21544 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21545 }
21546 static void *_p_wxImageTo_p_wxObject(void *x) {
21547 return (void *)((wxObject *) ((wxImage *) x));
21548 }
21549 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21550 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21551 }
21552 static void *_p_wxPaletteTo_p_wxObject(void *x) {
21553 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
21554 }
21555 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
21556 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
21557 }
21558 static void *_p_wxImageListTo_p_wxObject(void *x) {
21559 return (void *)((wxObject *) ((wxImageList *) x));
21560 }
21561 static void *_p_wxCursorTo_p_wxObject(void *x) {
21562 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
21563 }
21564 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
21565 return (void *)((wxObject *) ((wxEncodingConverter *) x));
21566 }
21567 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
21568 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
21569 }
21570 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21571 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21572 }
21573 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21574 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21575 }
21576 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21577 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21578 }
21579 static void *_p_wxWindowTo_p_wxObject(void *x) {
21580 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21581 }
21582 static void *_p_wxMenuTo_p_wxObject(void *x) {
21583 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21584 }
21585 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21586 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21587 }
21588 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
21589 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
21590 }
21591 static void *_p_wxBrushListTo_p_wxObject(void *x) {
21592 return (void *)((wxObject *) ((wxBrushList *) x));
21593 }
21594 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21595 return (void *)((wxObject *) ((wxFileSystem *) x));
21596 }
21597 static void *_p_wxBitmapTo_p_wxObject(void *x) {
21598 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
21599 }
21600 static void *_p_wxMaskTo_p_wxObject(void *x) {
21601 return (void *)((wxObject *) ((wxMask *) x));
21602 }
21603 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21604 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21605 }
21606 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21607 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21608 }
21609 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21610 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21611 }
21612 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21613 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21614 }
21615 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21616 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21617 }
21618 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21619 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21620 }
21621 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21622 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21623 }
21624 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21625 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21626 }
21627 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21628 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21629 }
21630 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21631 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21632 }
21633 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21634 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21635 }
21636 static void *_p_wxFontTo_p_wxObject(void *x) {
21637 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
21638 }
21639 static void *_p_wxBrushTo_p_wxObject(void *x) {
21640 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
21641 }
21642 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
21643 return (void *)((wxObject *) ((wxMetaFile *) x));
21644 }
21645 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21646 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21647 }
21648 static void *_p_wxColourTo_p_wxObject(void *x) {
21649 return (void *)((wxObject *) ((wxColour *) x));
21650 }
21651 static void *_p_wxFontListTo_p_wxObject(void *x) {
21652 return (void *)((wxObject *) ((wxFontList *) x));
21653 }
21654 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21655 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21656 }
21657 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21658 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21659 }
21660 static void *_p_wxControlTo_p_wxWindow(void *x) {
21661 return (void *)((wxWindow *) ((wxControl *) x));
21662 }
21663 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21664 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21665 }
21666 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
21667 return (void *)((wxWindow *) ((wxMenuBar *) x));
21668 }
21669 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}};
21670 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}};
21671 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}};
21672 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}};
21673 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}};
21674 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}};
21675 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}};
21676 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}};
21677 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}};
21678 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}};
21679 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}};
21680 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}};
21681 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}};
21682 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}};
21683 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}};
21684 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}};
21685 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}};
21686 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}};
21687 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}};
21688 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}};
21689 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}};
21690 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}};
21691 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}};
21692 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}};
21693 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}};
21694 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}};
21695 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}};
21696 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}};
21697 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}};
21698 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}};
21699 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}};
21700 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}};
21701 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}};
21702 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}};
21703 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}};
21704 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}};
21705 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}};
21706 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}};
21707 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}};
21708 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}};
21709 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}};
21710 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}};
21711 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}};
21712 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}};
21713 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}};
21714 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}};
21715 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}};
21716 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}};
21717 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}};
21718 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}};
21719 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}};
21720 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}};
21721 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}};
21722 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}};
21723 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}};
21724 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}};
21725 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}};
21726 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}};
21727 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}};
21728 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}};
21729 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}};
21730 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}};
21731
21732 static swig_type_info *swig_types_initial[] = {
21733 _swigt__p_wxPostScriptDC,
21734 _swigt__p_wxBrush,
21735 _swigt__p_wxColour,
21736 _swigt__p_wxDC,
21737 _swigt__p_wxMirrorDC,
21738 _swigt__p_form_ops_t,
21739 _swigt__p_wxDuplexMode,
21740 _swigt__p_wxPyFontEnumerator,
21741 _swigt__p_char,
21742 _swigt__p_wxIconLocation,
21743 _swigt__p_wxImage,
21744 _swigt__p_wxMetaFileDC,
21745 _swigt__p_wxMask,
21746 _swigt__p_wxSize,
21747 _swigt__p_wxFont,
21748 _swigt__p_wxWindow,
21749 _swigt__p_double,
21750 _swigt__p_wxMemoryDC,
21751 _swigt__p_wxFontMapper,
21752 _swigt__p_wxEffects,
21753 _swigt__p_wxNativeEncodingInfo,
21754 _swigt__p_wxPalette,
21755 _swigt__p_wxBitmap,
21756 _swigt__p_wxObject,
21757 _swigt__p_wxRegionIterator,
21758 _swigt__p_wxRect,
21759 _swigt__p_wxPaperSize,
21760 _swigt__p_wxString,
21761 _swigt__unsigned_int,
21762 _swigt__p_unsigned_int,
21763 _swigt__p_wxPrinterDC,
21764 _swigt__p_wxIconBundle,
21765 _swigt__p_wxPoint,
21766 _swigt__p_wxDash,
21767 _swigt__p_wxScreenDC,
21768 _swigt__p_wxCursor,
21769 _swigt__p_wxClientDC,
21770 _swigt__p_wxBufferedDC,
21771 _swigt__p_wxImageList,
21772 _swigt__p_unsigned_char,
21773 _swigt__p_wxGDIObject,
21774 _swigt__p_wxIcon,
21775 _swigt__p_wxLocale,
21776 _swigt__ptrdiff_t,
21777 _swigt__std__ptrdiff_t,
21778 _swigt__p_wxRegion,
21779 _swigt__p_wxConfigBase,
21780 _swigt__p_wxLanguageInfo,
21781 _swigt__p_wxWindowDC,
21782 _swigt__p_wxPrintData,
21783 _swigt__p_wxBrushList,
21784 _swigt__p_wxFontList,
21785 _swigt__p_wxPen,
21786 _swigt__p_wxBufferedPaintDC,
21787 _swigt__p_wxPaintDC,
21788 _swigt__p_wxPenList,
21789 _swigt__p_int,
21790 _swigt__p_wxMetaFile,
21791 _swigt__p_unsigned_long,
21792 _swigt__p_wxNativeFontInfo,
21793 _swigt__p_wxEncodingConverter,
21794 _swigt__p_wxColourDatabase,
21795 0
21796 };
21797
21798
21799 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
21800
21801 static swig_const_info swig_const_table[] = {
21802 {0, 0, 0, 0.0, 0, 0}};
21803
21804 #ifdef __cplusplus
21805 }
21806 #endif
21807
21808
21809 #ifdef __cplusplus
21810 extern "C" {
21811 #endif
21812
21813 /* Python-specific SWIG API */
21814 #define SWIG_newvarlink() SWIG_Python_newvarlink()
21815 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
21816 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
21817
21818 /* -----------------------------------------------------------------------------
21819 * global variable support code.
21820 * ----------------------------------------------------------------------------- */
21821
21822 typedef struct swig_globalvar {
21823 char *name; /* Name of global variable */
21824 PyObject *(*get_attr)(); /* Return the current value */
21825 int (*set_attr)(PyObject *); /* Set the value */
21826 struct swig_globalvar *next;
21827 } swig_globalvar;
21828
21829 typedef struct swig_varlinkobject {
21830 PyObject_HEAD
21831 swig_globalvar *vars;
21832 } swig_varlinkobject;
21833
21834 static PyObject *
21835 swig_varlink_repr(swig_varlinkobject *v) {
21836 v = v;
21837 return PyString_FromString("<Swig global variables>");
21838 }
21839
21840 static int
21841 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
21842 swig_globalvar *var;
21843 flags = flags;
21844 fprintf(fp,"Swig global variables { ");
21845 for (var = v->vars; var; var=var->next) {
21846 fprintf(fp,"%s", var->name);
21847 if (var->next) fprintf(fp,", ");
21848 }
21849 fprintf(fp," }\n");
21850 return 0;
21851 }
21852
21853 static PyObject *
21854 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
21855 swig_globalvar *var = v->vars;
21856 while (var) {
21857 if (strcmp(var->name,n) == 0) {
21858 return (*var->get_attr)();
21859 }
21860 var = var->next;
21861 }
21862 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21863 return NULL;
21864 }
21865
21866 static int
21867 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
21868 swig_globalvar *var = v->vars;
21869 while (var) {
21870 if (strcmp(var->name,n) == 0) {
21871 return (*var->set_attr)(p);
21872 }
21873 var = var->next;
21874 }
21875 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21876 return 1;
21877 }
21878
21879 static PyTypeObject varlinktype = {
21880 PyObject_HEAD_INIT(0)
21881 0, /* Number of items in variable part (ob_size) */
21882 (char *)"swigvarlink", /* Type name (tp_name) */
21883 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
21884 0, /* Itemsize (tp_itemsize) */
21885 0, /* Deallocator (tp_dealloc) */
21886 (printfunc) swig_varlink_print, /* Print (tp_print) */
21887 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
21888 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
21889 0, /* tp_compare */
21890 (reprfunc) swig_varlink_repr, /* tp_repr */
21891 0, /* tp_as_number */
21892 0, /* tp_as_sequence */
21893 0, /* tp_as_mapping */
21894 0, /* tp_hash */
21895 0, /* tp_call */
21896 0, /* tp_str */
21897 0, /* tp_getattro */
21898 0, /* tp_setattro */
21899 0, /* tp_as_buffer */
21900 0, /* tp_flags */
21901 0, /* tp_doc */
21902 #if PY_VERSION_HEX >= 0x02000000
21903 0, /* tp_traverse */
21904 0, /* tp_clear */
21905 #endif
21906 #if PY_VERSION_HEX >= 0x02010000
21907 0, /* tp_richcompare */
21908 0, /* tp_weaklistoffset */
21909 #endif
21910 #if PY_VERSION_HEX >= 0x02020000
21911 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
21912 #endif
21913 #if PY_VERSION_HEX >= 0x02030000
21914 0, /* tp_del */
21915 #endif
21916 #ifdef COUNT_ALLOCS
21917 0,0,0,0 /* tp_alloc -> tp_next */
21918 #endif
21919 };
21920
21921 /* Create a variable linking object for use later */
21922 static PyObject *
21923 SWIG_Python_newvarlink(void) {
21924 swig_varlinkobject *result = 0;
21925 result = PyMem_NEW(swig_varlinkobject,1);
21926 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
21927 result->ob_type = &varlinktype;
21928 result->vars = 0;
21929 result->ob_refcnt = 0;
21930 Py_XINCREF((PyObject *) result);
21931 return ((PyObject*) result);
21932 }
21933
21934 static void
21935 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
21936 swig_varlinkobject *v;
21937 swig_globalvar *gv;
21938 v= (swig_varlinkobject *) p;
21939 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
21940 gv->name = (char *) malloc(strlen(name)+1);
21941 strcpy(gv->name,name);
21942 gv->get_attr = get_attr;
21943 gv->set_attr = set_attr;
21944 gv->next = v->vars;
21945 v->vars = gv;
21946 }
21947
21948 /* -----------------------------------------------------------------------------
21949 * constants/methods manipulation
21950 * ----------------------------------------------------------------------------- */
21951
21952 /* Install Constants */
21953 static void
21954 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
21955 PyObject *obj = 0;
21956 size_t i;
21957 for (i = 0; constants[i].type; i++) {
21958 switch(constants[i].type) {
21959 case SWIG_PY_INT:
21960 obj = PyInt_FromLong(constants[i].lvalue);
21961 break;
21962 case SWIG_PY_FLOAT:
21963 obj = PyFloat_FromDouble(constants[i].dvalue);
21964 break;
21965 case SWIG_PY_STRING:
21966 if (constants[i].pvalue) {
21967 obj = PyString_FromString((char *) constants[i].pvalue);
21968 } else {
21969 Py_INCREF(Py_None);
21970 obj = Py_None;
21971 }
21972 break;
21973 case SWIG_PY_POINTER:
21974 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
21975 break;
21976 case SWIG_PY_BINARY:
21977 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
21978 break;
21979 default:
21980 obj = 0;
21981 break;
21982 }
21983 if (obj) {
21984 PyDict_SetItemString(d,constants[i].name,obj);
21985 Py_DECREF(obj);
21986 }
21987 }
21988 }
21989
21990 /* -----------------------------------------------------------------------------*/
21991 /* Fix SwigMethods to carry the callback ptrs when needed */
21992 /* -----------------------------------------------------------------------------*/
21993
21994 static void
21995 SWIG_Python_FixMethods(PyMethodDef *methods,
21996 swig_const_info *const_table,
21997 swig_type_info **types,
21998 swig_type_info **types_initial) {
21999 size_t i;
22000 for (i = 0; methods[i].ml_name; ++i) {
22001 char *c = methods[i].ml_doc;
22002 if (c && (c = strstr(c, "swig_ptr: "))) {
22003 int j;
22004 swig_const_info *ci = 0;
22005 char *name = c + 10;
22006 for (j = 0; const_table[j].type; j++) {
22007 if (strncmp(const_table[j].name, name,
22008 strlen(const_table[j].name)) == 0) {
22009 ci = &(const_table[j]);
22010 break;
22011 }
22012 }
22013 if (ci) {
22014 size_t shift = (ci->ptype) - types;
22015 swig_type_info *ty = types_initial[shift];
22016 size_t ldoc = (c - methods[i].ml_doc);
22017 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22018 char *ndoc = (char*)malloc(ldoc + lptr + 10);
22019 char *buff = ndoc;
22020 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
22021 strncpy(buff, methods[i].ml_doc, ldoc);
22022 buff += ldoc;
22023 strncpy(buff, "swig_ptr: ", 10);
22024 buff += 10;
22025 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22026 methods[i].ml_doc = ndoc;
22027 }
22028 }
22029 }
22030 }
22031
22032 /* -----------------------------------------------------------------------------*
22033 * Initialize type list
22034 * -----------------------------------------------------------------------------*/
22035
22036 #if PY_MAJOR_VERSION < 2
22037 /* PyModule_AddObject function was introduced in Python 2.0. The following function
22038 is copied out of Python/modsupport.c in python version 2.3.4 */
22039 static int
22040 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
22041 {
22042 PyObject *dict;
22043 if (!PyModule_Check(m)) {
22044 PyErr_SetString(PyExc_TypeError,
22045 "PyModule_AddObject() needs module as first arg");
22046 return -1;
22047 }
22048 if (!o) {
22049 PyErr_SetString(PyExc_TypeError,
22050 "PyModule_AddObject() needs non-NULL value");
22051 return -1;
22052 }
22053
22054 dict = PyModule_GetDict(m);
22055 if (dict == NULL) {
22056 /* Internal error -- modules must have a dict! */
22057 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
22058 PyModule_GetName(m));
22059 return -1;
22060 }
22061 if (PyDict_SetItemString(dict, name, o))
22062 return -1;
22063 Py_DECREF(o);
22064 return 0;
22065 }
22066 #endif
22067
22068 static swig_type_info **
22069 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
22070 static PyMethodDef swig_empty_runtime_method_table[] = {
22071 {
22072 NULL, NULL, 0, NULL
22073 }
22074 };/* Sentinel */
22075
22076 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
22077 swig_empty_runtime_method_table);
22078 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
22079 if (pointer && module) {
22080 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
22081 }
22082 return type_list_handle;
22083 }
22084
22085 static swig_type_info **
22086 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
22087 swig_type_info **type_pointer;
22088
22089 /* first check if module already created */
22090 type_pointer = SWIG_Python_GetTypeListHandle();
22091 if (type_pointer) {
22092 return type_pointer;
22093 } else {
22094 /* create a new module and variable */
22095 return SWIG_Python_SetTypeListHandle(type_list_handle);
22096 }
22097 }
22098
22099 #ifdef __cplusplus
22100 }
22101 #endif
22102
22103 /* -----------------------------------------------------------------------------*
22104 * Partial Init method
22105 * -----------------------------------------------------------------------------*/
22106
22107 #ifdef SWIG_LINK_RUNTIME
22108 #ifdef __cplusplus
22109 extern "C"
22110 #endif
22111 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
22112 #endif
22113
22114 #ifdef __cplusplus
22115 extern "C"
22116 #endif
22117 SWIGEXPORT(void) SWIG_init(void) {
22118 static PyObject *SWIG_globals = 0;
22119 static int typeinit = 0;
22120 PyObject *m, *d;
22121 int i;
22122 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
22123
22124 /* Fix SwigMethods to carry the callback ptrs when needed */
22125 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
22126
22127 m = Py_InitModule((char *) SWIG_name, SwigMethods);
22128 d = PyModule_GetDict(m);
22129
22130 if (!typeinit) {
22131 #ifdef SWIG_LINK_RUNTIME
22132 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
22133 #else
22134 # ifndef SWIG_STATIC_RUNTIME
22135 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
22136 # endif
22137 #endif
22138 for (i = 0; swig_types_initial[i]; i++) {
22139 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
22140 }
22141 typeinit = 1;
22142 }
22143 SWIG_InstallConstants(d,swig_const_table);
22144
22145 {
22146 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
22147 }
22148 {
22149 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
22150 }
22151 {
22152 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
22153 }
22154 {
22155 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
22156 }
22157 {
22158 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
22159 }
22160 {
22161 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
22162 }
22163 {
22164 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
22165 }
22166 {
22167 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
22168 }
22169 {
22170 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
22171 }
22172 {
22173 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
22174 }
22175 {
22176 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
22177 }
22178 {
22179 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
22180 }
22181 {
22182 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
22183 }
22184 {
22185 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
22186 }
22187 {
22188 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
22189 }
22190 {
22191 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
22192 }
22193 {
22194 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
22195 }
22196 {
22197 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
22198 }
22199 {
22200 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
22201 }
22202 {
22203 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
22204 }
22205 {
22206 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
22207 }
22208 {
22209 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
22210 }
22211 {
22212 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
22213 }
22214 {
22215 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
22216 }
22217 {
22218 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
22219 }
22220 {
22221 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
22222 }
22223 {
22224 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
22225 }
22226 {
22227 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
22228 }
22229 {
22230 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
22231 }
22232 {
22233 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
22234 }
22235 {
22236 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
22237 }
22238 {
22239 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
22240 }
22241 {
22242 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
22243 }
22244 {
22245 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
22246 }
22247 {
22248 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
22249 }
22250 {
22251 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
22252 }
22253 {
22254 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
22255 }
22256 {
22257 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
22258 }
22259 {
22260 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
22261 }
22262 {
22263 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
22264 }
22265 {
22266 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
22267 }
22268 {
22269 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
22270 }
22271 {
22272 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
22273 }
22274 {
22275 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
22276 }
22277 {
22278 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
22279 }
22280 {
22281 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
22282 }
22283 {
22284 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
22285 }
22286 {
22287 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
22288 }
22289 {
22290 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
22291 }
22292 {
22293 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
22294 }
22295 {
22296 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
22297 }
22298 {
22299 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
22300 }
22301 {
22302 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
22303 }
22304 {
22305 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
22306 }
22307 {
22308 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
22309 }
22310 {
22311 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
22312 }
22313 {
22314 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
22315 }
22316 {
22317 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
22318 }
22319 {
22320 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
22321 }
22322 {
22323 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
22324 }
22325 {
22326 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
22327 }
22328 {
22329 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
22330 }
22331 {
22332 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
22333 }
22334 {
22335 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
22336 }
22337 {
22338 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
22339 }
22340 {
22341 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
22342 }
22343 {
22344 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
22345 }
22346 {
22347 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
22348 }
22349 {
22350 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
22351 }
22352 {
22353 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
22354 }
22355 {
22356 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
22357 }
22358 {
22359 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
22360 }
22361 {
22362 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
22363 }
22364 {
22365 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
22366 }
22367 {
22368 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
22369 }
22370 {
22371 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
22372 }
22373 {
22374 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
22375 }
22376 {
22377 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
22378 }
22379 {
22380 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
22381 }
22382 {
22383 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
22384 }
22385 {
22386 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
22387 }
22388 {
22389 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
22390 }
22391 {
22392 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
22393 }
22394 {
22395 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
22396 }
22397 {
22398 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
22399 }
22400 {
22401 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
22402 }
22403 {
22404 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
22405 }
22406 {
22407 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
22408 }
22409 {
22410 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
22411 }
22412 {
22413 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
22414 }
22415 {
22416 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
22417 }
22418 {
22419 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
22420 }
22421 {
22422 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
22423 }
22424 {
22425 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
22426 }
22427 {
22428 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
22429 }
22430 {
22431 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
22432 }
22433 {
22434 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
22435 }
22436 {
22437 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
22438 }
22439 {
22440 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
22441 }
22442 {
22443 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
22444 }
22445 {
22446 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
22447 }
22448 {
22449 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
22450 }
22451 {
22452 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
22453 }
22454 {
22455 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
22456 }
22457 {
22458 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
22459 }
22460 {
22461 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
22462 }
22463 {
22464 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
22465 }
22466 {
22467 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
22468 }
22469 {
22470 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
22471 }
22472 {
22473 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
22474 }
22475 {
22476 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
22477 }
22478 {
22479 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
22480 }
22481 {
22482 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
22483 }
22484 {
22485 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
22486 }
22487 {
22488 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
22489 }
22490 {
22491 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
22492 }
22493 {
22494 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
22495 }
22496 {
22497 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
22498 }
22499 {
22500 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
22501 }
22502 {
22503 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
22504 }
22505 {
22506 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
22507 }
22508 {
22509 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
22510 }
22511 {
22512 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
22513 }
22514 {
22515 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
22516 }
22517 {
22518 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
22519 }
22520 {
22521 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
22522 }
22523 {
22524 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
22525 }
22526
22527 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
22528
22529 {
22530 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
22531 }
22532 {
22533 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
22534 }
22535 {
22536 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
22537 }
22538 {
22539 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
22540 }
22541 {
22542 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
22543 }
22544 {
22545 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
22546 }
22547 {
22548 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
22549 }
22550 {
22551 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
22552 }
22553 {
22554 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
22555 }
22556 {
22557 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
22558 }
22559 {
22560 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
22561 }
22562 {
22563 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
22564 }
22565 {
22566 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
22567 }
22568 {
22569 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
22570 }
22571 {
22572 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
22573 }
22574 {
22575 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
22576 }
22577 {
22578 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
22579 }
22580 {
22581 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
22582 }
22583 {
22584 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
22585 }
22586 {
22587 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
22588 }
22589 {
22590 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
22591 }
22592 {
22593 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
22594 }
22595 {
22596 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
22597 }
22598 {
22599 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
22600 }
22601 {
22602 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
22603 }
22604 {
22605 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
22606 }
22607 {
22608 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
22609 }
22610 {
22611 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
22612 }
22613 {
22614 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
22615 }
22616 {
22617 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
22618 }
22619 {
22620 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
22621 }
22622 {
22623 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
22624 }
22625 {
22626 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
22627 }
22628 {
22629 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
22630 }
22631 {
22632 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
22633 }
22634 {
22635 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
22636 }
22637 {
22638 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
22639 }
22640 {
22641 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
22642 }
22643 {
22644 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
22645 }
22646 {
22647 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
22648 }
22649 {
22650 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
22651 }
22652 {
22653 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
22654 }
22655 {
22656 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
22657 }
22658 {
22659 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
22660 }
22661 {
22662 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
22663 }
22664 {
22665 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
22666 }
22667 {
22668 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
22669 }
22670 {
22671 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
22672 }
22673 {
22674 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
22675 }
22676 {
22677 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
22678 }
22679 {
22680 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
22681 }
22682 {
22683 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
22684 }
22685 {
22686 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
22687 }
22688 {
22689 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
22690 }
22691 {
22692 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
22693 }
22694 {
22695 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
22696 }
22697 {
22698 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
22699 }
22700 {
22701 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
22702 }
22703 {
22704 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
22705 }
22706 {
22707 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
22708 }
22709 {
22710 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
22711 }
22712 {
22713 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
22714 }
22715 {
22716 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
22717 }
22718 {
22719 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
22720 }
22721 {
22722 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
22723 }
22724 {
22725 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
22726 }
22727 {
22728 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
22729 }
22730 {
22731 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
22732 }
22733 {
22734 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
22735 }
22736 {
22737 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
22738 }
22739 {
22740 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
22741 }
22742 {
22743 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
22744 }
22745 {
22746 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
22747 }
22748 {
22749 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
22750 }
22751 {
22752 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
22753 }
22754 {
22755 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
22756 }
22757 {
22758 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
22759 }
22760 {
22761 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
22762 }
22763 {
22764 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
22765 }
22766 {
22767 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
22768 }
22769 {
22770 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
22771 }
22772 {
22773 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
22774 }
22775 {
22776 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
22777 }
22778 {
22779 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
22780 }
22781 {
22782 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
22783 }
22784 {
22785 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
22786 }
22787 {
22788 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
22789 }
22790 {
22791 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
22792 }
22793 {
22794 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
22795 }
22796 {
22797 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
22798 }
22799 {
22800 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
22801 }
22802 {
22803 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
22804 }
22805 {
22806 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
22807 }
22808 {
22809 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
22810 }
22811 {
22812 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
22813 }
22814 {
22815 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
22816 }
22817 {
22818 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
22819 }
22820 {
22821 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
22822 }
22823 {
22824 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
22825 }
22826 {
22827 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
22828 }
22829 {
22830 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
22831 }
22832 {
22833 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
22834 }
22835 {
22836 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
22837 }
22838 {
22839 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
22840 }
22841 {
22842 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
22843 }
22844 {
22845 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
22846 }
22847 {
22848 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
22849 }
22850 {
22851 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
22852 }
22853 {
22854 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
22855 }
22856 {
22857 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
22858 }
22859 {
22860 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
22861 }
22862 {
22863 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
22864 }
22865 {
22866 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
22867 }
22868 {
22869 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
22870 }
22871 {
22872 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
22873 }
22874 {
22875 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
22876 }
22877 {
22878 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
22879 }
22880 {
22881 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
22882 }
22883 {
22884 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
22885 }
22886 {
22887 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
22888 }
22889 {
22890 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
22891 }
22892 {
22893 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
22894 }
22895 {
22896 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
22897 }
22898 {
22899 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
22900 }
22901 {
22902 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
22903 }
22904 {
22905 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
22906 }
22907 {
22908 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
22909 }
22910 {
22911 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
22912 }
22913 {
22914 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
22915 }
22916 {
22917 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
22918 }
22919 {
22920 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
22921 }
22922 {
22923 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
22924 }
22925 {
22926 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
22927 }
22928 {
22929 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
22930 }
22931 {
22932 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
22933 }
22934 {
22935 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
22936 }
22937 {
22938 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
22939 }
22940 {
22941 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
22942 }
22943 {
22944 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
22945 }
22946 {
22947 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
22948 }
22949 {
22950 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
22951 }
22952 {
22953 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
22954 }
22955 {
22956 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
22957 }
22958 {
22959 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
22960 }
22961 {
22962 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
22963 }
22964 {
22965 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
22966 }
22967 {
22968 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
22969 }
22970 {
22971 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
22972 }
22973 {
22974 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
22975 }
22976 {
22977 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
22978 }
22979 {
22980 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
22981 }
22982 {
22983 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
22984 }
22985 {
22986 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
22987 }
22988 {
22989 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
22990 }
22991 {
22992 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
22993 }
22994 {
22995 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
22996 }
22997 {
22998 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
22999 }
23000 {
23001 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
23002 }
23003 {
23004 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
23005 }
23006 {
23007 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
23008 }
23009 {
23010 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
23011 }
23012 {
23013 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
23014 }
23015 {
23016 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
23017 }
23018 {
23019 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
23020 }
23021 {
23022 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
23023 }
23024 {
23025 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
23026 }
23027 {
23028 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
23029 }
23030 {
23031 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
23032 }
23033 {
23034 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
23035 }
23036 {
23037 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
23038 }
23039 {
23040 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
23041 }
23042 {
23043 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
23044 }
23045 {
23046 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
23047 }
23048 {
23049 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
23050 }
23051 {
23052 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
23053 }
23054 {
23055 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
23056 }
23057 {
23058 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
23059 }
23060 {
23061 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
23062 }
23063 {
23064 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
23065 }
23066 {
23067 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
23068 }
23069 {
23070 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
23071 }
23072 {
23073 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
23074 }
23075 {
23076 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
23077 }
23078 {
23079 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
23080 }
23081 {
23082 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
23083 }
23084 {
23085 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
23086 }
23087 {
23088 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
23089 }
23090 {
23091 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
23092 }
23093 {
23094 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
23095 }
23096 {
23097 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
23098 }
23099 {
23100 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
23101 }
23102 {
23103 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
23104 }
23105 {
23106 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
23107 }
23108 {
23109 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
23110 }
23111 {
23112 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
23113 }
23114 {
23115 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
23116 }
23117 {
23118 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
23119 }
23120 {
23121 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
23122 }
23123 {
23124 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
23125 }
23126 {
23127 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
23128 }
23129 {
23130 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
23131 }
23132 {
23133 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
23134 }
23135 {
23136 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
23137 }
23138 {
23139 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
23140 }
23141 {
23142 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
23143 }
23144 {
23145 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
23146 }
23147 {
23148 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
23149 }
23150 {
23151 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
23152 }
23153 {
23154 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
23155 }
23156 {
23157 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
23158 }
23159 {
23160 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
23161 }
23162 {
23163 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
23164 }
23165 {
23166 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
23167 }
23168 {
23169 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
23170 }
23171 {
23172 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
23173 }
23174 {
23175 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
23176 }
23177 {
23178 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
23179 }
23180 {
23181 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
23182 }
23183 {
23184 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
23185 }
23186 {
23187 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
23188 }
23189 {
23190 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
23191 }
23192 {
23193 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
23194 }
23195 {
23196 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
23197 }
23198 {
23199 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
23200 }
23201 {
23202 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
23203 }
23204 {
23205 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
23206 }
23207 {
23208 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
23209 }
23210 {
23211 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
23212 }
23213 {
23214 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
23215 }
23216 {
23217 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
23218 }
23219 {
23220 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
23221 }
23222 {
23223 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
23224 }
23225 {
23226 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
23227 }
23228 {
23229 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
23230 }
23231 {
23232 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
23233 }
23234 {
23235 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
23236 }
23237 {
23238 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
23239 }
23240 {
23241 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
23242 }
23243 {
23244 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
23245 }
23246 {
23247 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
23248 }
23249 {
23250 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
23251 }
23252 {
23253 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
23254 }
23255 {
23256 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
23257 }
23258 {
23259 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
23260 }
23261 {
23262 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
23263 }
23264 {
23265 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
23266 }
23267 {
23268 PyDict_SetItemString(d,"BUFFER_VIRTUAL_AREA", SWIG_From_int((int)(wxBUFFER_VIRTUAL_AREA)));
23269 }
23270 {
23271 PyDict_SetItemString(d,"BUFFER_CLIENT_AREA", SWIG_From_int((int)(wxBUFFER_CLIENT_AREA)));
23272 }
23273 {
23274 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
23275 }
23276 {
23277 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
23278 }
23279 {
23280 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
23281 }
23282 {
23283 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
23284 }
23285 {
23286 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
23287 }
23288 {
23289 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
23290 }
23291 {
23292 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
23293 }
23294 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
23295 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
23296 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
23297 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
23298 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
23299 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
23300 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
23301 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
23302 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
23303 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
23304 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
23305 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
23306 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
23307 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
23308 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
23309 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
23310 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
23311 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
23312 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
23313 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
23314 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
23315 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
23316 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
23317 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
23318 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
23319 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
23320 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
23321 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
23322 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
23323 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
23324 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
23325 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
23326 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
23327 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
23328 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
23329 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
23330 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
23331 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
23332 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
23333 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
23334 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
23335 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
23336 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
23337 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
23338 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
23339 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
23340 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
23341
23342 // Work around a chicken/egg problem in drawlist.cpp
23343 wxPyDrawList_SetAPIPtr();
23344
23345 }
23346
wxWidgets (Impactor)