]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_gdi_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
added a test to check how exception handling works with Win32 SEH; corrected copyright
[wxWidgets.git] / wxPython / src / msw / _gdi_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxPostScriptDC swig_types[0]
1342 #define SWIGTYPE_p_wxBrush swig_types[1]
1343 #define SWIGTYPE_p_wxColour swig_types[2]
1344 #define SWIGTYPE_p_wxDC swig_types[3]
1345 #define SWIGTYPE_p_wxMirrorDC swig_types[4]
1346 #define SWIGTYPE_p_form_ops_t swig_types[5]
1347 #define SWIGTYPE_p_wxDuplexMode swig_types[6]
1348 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[7]
1349 #define SWIGTYPE_p_char swig_types[8]
1350 #define SWIGTYPE_p_wxIconLocation swig_types[9]
1351 #define SWIGTYPE_p_wxImage swig_types[10]
1352 #define SWIGTYPE_p_wxMetaFileDC swig_types[11]
1353 #define SWIGTYPE_p_wxMask swig_types[12]
1354 #define SWIGTYPE_p_wxSize swig_types[13]
1355 #define SWIGTYPE_p_wxFont swig_types[14]
1356 #define SWIGTYPE_p_wxWindow swig_types[15]
1357 #define SWIGTYPE_p_double swig_types[16]
1358 #define SWIGTYPE_p_wxMemoryDC swig_types[17]
1359 #define SWIGTYPE_p_wxFontMapper swig_types[18]
1360 #define SWIGTYPE_p_wxEffects swig_types[19]
1361 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[20]
1362 #define SWIGTYPE_p_wxPalette swig_types[21]
1363 #define SWIGTYPE_p_wxBitmap swig_types[22]
1364 #define SWIGTYPE_p_wxObject swig_types[23]
1365 #define SWIGTYPE_p_wxRegionIterator swig_types[24]
1366 #define SWIGTYPE_p_wxRect swig_types[25]
1367 #define SWIGTYPE_p_wxPaperSize swig_types[26]
1368 #define SWIGTYPE_p_wxString swig_types[27]
1369 #define SWIGTYPE_unsigned_int swig_types[28]
1370 #define SWIGTYPE_p_unsigned_int swig_types[29]
1371 #define SWIGTYPE_p_wxPrinterDC swig_types[30]
1372 #define SWIGTYPE_p_wxIconBundle swig_types[31]
1373 #define SWIGTYPE_p_wxPoint swig_types[32]
1374 #define SWIGTYPE_p_wxDash swig_types[33]
1375 #define SWIGTYPE_p_wxScreenDC swig_types[34]
1376 #define SWIGTYPE_p_wxCursor swig_types[35]
1377 #define SWIGTYPE_p_wxClientDC swig_types[36]
1378 #define SWIGTYPE_p_wxBufferedDC swig_types[37]
1379 #define SWIGTYPE_p_wxImageList swig_types[38]
1380 #define SWIGTYPE_p_unsigned_char swig_types[39]
1381 #define SWIGTYPE_p_wxGDIObject swig_types[40]
1382 #define SWIGTYPE_p_wxIcon swig_types[41]
1383 #define SWIGTYPE_p_wxLocale swig_types[42]
1384 #define SWIGTYPE_ptrdiff_t swig_types[43]
1385 #define SWIGTYPE_std__ptrdiff_t swig_types[44]
1386 #define SWIGTYPE_p_wxRegion swig_types[45]
1387 #define SWIGTYPE_p_wxConfigBase swig_types[46]
1388 #define SWIGTYPE_p_wxLanguageInfo swig_types[47]
1389 #define SWIGTYPE_p_wxWindowDC swig_types[48]
1390 #define SWIGTYPE_p_wxPrintData swig_types[49]
1391 #define SWIGTYPE_p_wxBrushList swig_types[50]
1392 #define SWIGTYPE_p_wxFontList swig_types[51]
1393 #define SWIGTYPE_p_wxPen swig_types[52]
1394 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[53]
1395 #define SWIGTYPE_p_wxPaintDC swig_types[54]
1396 #define SWIGTYPE_p_wxPenList swig_types[55]
1397 #define SWIGTYPE_p_int swig_types[56]
1398 #define SWIGTYPE_p_wxMetaFile swig_types[57]
1399 #define SWIGTYPE_p_unsigned_long swig_types[58]
1400 #define SWIGTYPE_p_wxNativeFontInfo swig_types[59]
1401 #define SWIGTYPE_p_wxEncodingConverter swig_types[60]
1402 #define SWIGTYPE_p_wxColourDatabase swig_types[61]
1403 static swig_type_info *swig_types[63];
1404
1405 /* -------- TYPES TABLE (END) -------- */
1406
1407
1408 /*-----------------------------------------------
1409 @(target):= _gdi_.so
1410 ------------------------------------------------*/
1411 #define SWIG_init init_gdi_
1412
1413 #define SWIG_name "_gdi_"
1414
1415 #include "wx/wxPython/wxPython.h"
1416 #include "wx/wxPython/pyclasses.h"
1417
1418
1419 static const wxString wxPyEmptyString(wxEmptyString);
1420
1421 #include <limits.h>
1422
1423
1424 SWIGINTERN int
1425 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1426 const char *errmsg)
1427 {
1428 if (value < min_value) {
1429 if (errmsg) {
1430 PyErr_Format(PyExc_OverflowError,
1431 "value %ld is less than '%s' minimum %ld",
1432 value, errmsg, min_value);
1433 }
1434 return 0;
1435 } else if (value > max_value) {
1436 if (errmsg) {
1437 PyErr_Format(PyExc_OverflowError,
1438 "value %ld is greater than '%s' maximum %ld",
1439 value, errmsg, max_value);
1440 }
1441 return 0;
1442 }
1443 return 1;
1444 }
1445
1446
1447 SWIGINTERN int
1448 SWIG_AsVal_long(PyObject* obj, long* val)
1449 {
1450 if (PyNumber_Check(obj)) {
1451 if (val) *val = PyInt_AsLong(obj);
1452 return 1;
1453 }
1454 else {
1455 SWIG_type_error("number", obj);
1456 }
1457 return 0;
1458 }
1459
1460
1461 #if INT_MAX != LONG_MAX
1462 SWIGINTERN int
1463 SWIG_AsVal_int(PyObject *obj, int *val)
1464 {
1465 const char* errmsg = val ? "int" : (char*)0;
1466 long v;
1467 if (SWIG_AsVal_long(obj, &v)) {
1468 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1469 if (val) *val = (int)(v);
1470 return 1;
1471 } else {
1472 return 0;
1473 }
1474 } else {
1475 PyErr_Clear();
1476 }
1477 if (val) {
1478 SWIG_type_error(errmsg, obj);
1479 }
1480 return 0;
1481 }
1482 #else
1483 SWIGINTERNSHORT int
1484 SWIG_AsVal_int(PyObject *obj, int *val)
1485 {
1486 return SWIG_AsVal_long(obj,(long*)val);
1487 }
1488 #endif
1489
1490
1491 SWIGINTERN int
1492 SWIG_AsVal_bool(PyObject *obj, bool *val)
1493 {
1494 if (obj == Py_True) {
1495 if (val) *val = true;
1496 return 1;
1497 }
1498 if (obj == Py_False) {
1499 if (val) *val = false;
1500 return 1;
1501 }
1502 int res = 0;
1503 if (SWIG_AsVal_int(obj, &res)) {
1504 if (val) *val = res ? true : false;
1505 return 1;
1506 } else {
1507 PyErr_Clear();
1508 }
1509 if (val) {
1510 SWIG_type_error("bool", obj);
1511 }
1512 return 0;
1513 }
1514
1515
1516 SWIGINTERNSHORT bool
1517 SWIG_As_bool(PyObject* obj)
1518 {
1519 bool v;
1520 if (!SWIG_AsVal_bool(obj, &v)) {
1521 /*
1522 this is needed to make valgrind/purify happier.
1523 */
1524 memset((void*)&v, 0, sizeof(bool));
1525 }
1526 return v;
1527 }
1528
1529
1530 SWIGINTERNSHORT int
1531 SWIG_Check_bool(PyObject* obj)
1532 {
1533 return SWIG_AsVal_bool(obj, (bool*)0);
1534 }
1535
1536
1537 SWIGINTERN int
1538 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1539 {
1540 long v = 0;
1541 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1542 SWIG_type_error("unsigned number", obj);
1543 }
1544 else if (val)
1545 *val = (unsigned long)v;
1546 return 1;
1547 }
1548
1549
1550 SWIGINTERNSHORT int
1551 SWIG_CheckUnsignedLongInRange(unsigned long value,
1552 unsigned long max_value,
1553 const char *errmsg)
1554 {
1555 if (value > max_value) {
1556 if (errmsg) {
1557 PyErr_Format(PyExc_OverflowError,
1558 "value %lu is greater than '%s' minimum %lu",
1559 value, errmsg, max_value);
1560 }
1561 return 0;
1562 }
1563 return 1;
1564 }
1565
1566
1567 SWIGINTERN int
1568 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1569 {
1570 const char* errmsg = val ? "unsigned char" : (char*)0;
1571 unsigned long v;
1572 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1573 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1574 if (val) *val = (unsigned char)(v);
1575 return 1;
1576 } else {
1577 return 0;
1578 }
1579 } else {
1580 PyErr_Clear();
1581 }
1582 if (val) {
1583 SWIG_type_error(errmsg, obj);
1584 }
1585 return 0;
1586 }
1587
1588
1589 SWIGINTERNSHORT unsigned char
1590 SWIG_As_unsigned_SS_char(PyObject* obj)
1591 {
1592 unsigned char v;
1593 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1594 /*
1595 this is needed to make valgrind/purify happier.
1596 */
1597 memset((void*)&v, 0, sizeof(unsigned char));
1598 }
1599 return v;
1600 }
1601
1602
1603 SWIGINTERNSHORT int
1604 SWIG_Check_unsigned_SS_char(PyObject* obj)
1605 {
1606 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1607 }
1608
1609
1610 SWIGINTERNSHORT unsigned long
1611 SWIG_As_unsigned_SS_long(PyObject* obj)
1612 {
1613 unsigned long v;
1614 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1615 /*
1616 this is needed to make valgrind/purify happier.
1617 */
1618 memset((void*)&v, 0, sizeof(unsigned long));
1619 }
1620 return v;
1621 }
1622
1623
1624 SWIGINTERNSHORT int
1625 SWIG_Check_unsigned_SS_long(PyObject* obj)
1626 {
1627 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1628 }
1629
1630
1631 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1632 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1633 /*@@*/
1634
1635
1636 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1637 #define SWIG_From_long PyInt_FromLong
1638 /*@@*/
1639
1640 static PyObject *wxColour_Get(wxColour *self){
1641 PyObject* rv = PyTuple_New(3);
1642 int red = -1;
1643 int green = -1;
1644 int blue = -1;
1645 if (self->Ok()) {
1646 red = self->Red();
1647 green = self->Green();
1648 blue = self->Blue();
1649 }
1650 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1651 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1652 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1653 return rv;
1654 }
1655 static unsigned long wxColour_GetRGB(wxColour *self){
1656 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1657 }
1658
1659 SWIGINTERNSHORT PyObject*
1660 SWIG_From_unsigned_SS_long(unsigned long value)
1661 {
1662 return (value > LONG_MAX) ?
1663 PyLong_FromUnsignedLong(value)
1664 : PyInt_FromLong((long)(value));
1665 }
1666
1667
1668 SWIGINTERNSHORT int
1669 SWIG_As_int(PyObject* obj)
1670 {
1671 int v;
1672 if (!SWIG_AsVal_int(obj, &v)) {
1673 /*
1674 this is needed to make valgrind/purify happier.
1675 */
1676 memset((void*)&v, 0, sizeof(int));
1677 }
1678 return v;
1679 }
1680
1681
1682 SWIGINTERNSHORT int
1683 SWIG_Check_int(PyObject* obj)
1684 {
1685 return SWIG_AsVal_int(obj, (int*)0);
1686 }
1687
1688
1689 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1690 #define SWIG_From_int PyInt_FromLong
1691 /*@@*/
1692
1693
1694 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1695 PyObject* o2;
1696 PyObject* o3;
1697
1698 if (!target) {
1699 target = o;
1700 } else if (target == Py_None) {
1701 Py_DECREF(Py_None);
1702 target = o;
1703 } else {
1704 if (!PyTuple_Check(target)) {
1705 o2 = target;
1706 target = PyTuple_New(1);
1707 PyTuple_SetItem(target, 0, o2);
1708 }
1709 o3 = PyTuple_New(1);
1710 PyTuple_SetItem(o3, 0, o);
1711
1712 o2 = target;
1713 target = PySequence_Concat(o2, o3);
1714 Py_DECREF(o2);
1715 Py_DECREF(o3);
1716 }
1717 return target;
1718 }
1719
1720
1721 static PyObject *wxPen_GetDashes(wxPen *self){
1722 wxDash* dashes;
1723 int count = self->GetDashes(&dashes);
1724 bool blocked = wxPyBeginBlockThreads();
1725 PyObject* retval = PyList_New(0);
1726 for (int x=0; x<count; x++) {
1727 PyObject* pyint = PyInt_FromLong(dashes[x]);
1728 PyList_Append(retval, pyint);
1729 Py_DECREF(pyint);
1730 }
1731 wxPyEndBlockThreads(blocked);
1732 return retval;
1733 }
1734 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1735 bool blocked = wxPyBeginBlockThreads();
1736 int size = PyList_Size(pyDashes);
1737 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1738
1739 // black magic warning! The array of wxDashes needs to exist as
1740 // long as the pen does because wxPen does not copy the array. So
1741 // stick a copy in a Python string object and attach it to _self,
1742 // and then call SetDashes with a pointer to that array. Then
1743 // when the Python pen object is destroyed the array will be
1744 // cleaned up too.
1745 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1746 PyObject_SetAttrString(_self, "_dashes", strDashes);
1747
1748 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1749 delete [] dashes;
1750 Py_DECREF(strDashes);
1751 wxPyEndBlockThreads(blocked);
1752 }
1753 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1754 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1755
1756 #include <wx/image.h>
1757
1758 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1759 char** cArray = NULL;
1760 int count;
1761
1762 if (!PyList_Check(listOfStrings)) {
1763 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1764 return NULL;
1765 }
1766 count = PyList_Size(listOfStrings);
1767 cArray = new char*[count];
1768
1769 for(int x=0; x<count; x++) {
1770 // TODO: Need some validation and error checking here
1771 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1772 }
1773 return cArray;
1774 }
1775
1776
1777 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1778 char** cArray = NULL;
1779 wxBitmap* bmp;
1780
1781 cArray = ConvertListOfStrings(listOfStrings);
1782 if (! cArray)
1783 return NULL;
1784 bmp = new wxBitmap(cArray);
1785 delete [] cArray;
1786 return bmp;
1787 }
1788 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1789 char* buf;
1790 int length;
1791 PyString_AsStringAndSize(bits, &buf, &length);
1792 return new wxBitmap(buf, width, height, depth);
1793 }
1794
1795 SWIGINTERNSHORT long
1796 SWIG_As_long(PyObject* obj)
1797 {
1798 long v;
1799 if (!SWIG_AsVal_long(obj, &v)) {
1800 /*
1801 this is needed to make valgrind/purify happier.
1802 */
1803 memset((void*)&v, 0, sizeof(long));
1804 }
1805 return v;
1806 }
1807
1808
1809 SWIGINTERNSHORT int
1810 SWIG_Check_long(PyObject* obj)
1811 {
1812 return SWIG_AsVal_long(obj, (long*)0);
1813 }
1814
1815 static void wxBitmap_SetHandle(wxBitmap *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1816 static wxSize wxBitmap_GetSize(wxBitmap *self){
1817 wxSize size(self->GetWidth(), self->GetHeight());
1818 return size;
1819 }
1820 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1821 wxMask *mask = new wxMask(*self, colour);
1822 self->SetMask(mask);
1823 }
1824 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1825 self->SetWidth(size.x);
1826 self->SetHeight(size.y);
1827 }
1828 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1829 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1830 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1831 if ( !colour.Ok() )
1832 return new wxMask(bitmap, *wxBLACK);
1833 else
1834 return new wxMask(bitmap, colour);
1835 }
1836
1837 #include <wx/iconbndl.h>
1838
1839 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1840 wxIcon* icon = new wxIcon();
1841 icon->CopyFromBitmap(bmp);
1842 return icon;
1843 }
1844 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1845 char** cArray = NULL;
1846 wxIcon* icon;
1847
1848 cArray = ConvertListOfStrings(listOfStrings);
1849 if (! cArray)
1850 return NULL;
1851 icon = new wxIcon(cArray);
1852 delete [] cArray;
1853 return icon;
1854 }
1855 static void wxIcon_SetHandle(wxIcon *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1856 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1857
1858 return new wxIconLocation(*filename, num);
1859
1860
1861
1862 }
1863 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1864
1865 self->SetIndex(num);
1866
1867
1868
1869 }
1870 static int wxIconLocation_GetIndex(wxIconLocation *self){
1871
1872 return self->GetIndex();
1873
1874
1875
1876 }
1877 static wxCursor *new_wxCursor(wxString const *cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1878 #ifdef __WXGTK__
1879 wxCHECK_MSG(false, NULL,
1880 wxT("wx.Cursor constructor not implemented for wxGTK, use wx.StockCursor, wx.CursorFromImage, or wx.CursorFromBits instead."));
1881 #else
1882 return new wxCursor(*cursorName, type, hotSpotX, hotSpotY);
1883 #endif
1884 }
1885 static void wxCursor_SetHandle(wxCursor *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1886
1887
1888 static void wxRegionIterator_Next(wxRegionIterator *self){
1889 (*self) ++;
1890 }
1891 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1892 return self->operator bool();
1893 }
1894
1895 #include <wx/fontutil.h>
1896 #include <wx/fontmap.h>
1897 #include <wx/fontenum.h>
1898
1899 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1900 return self->ToString();
1901 }
1902
1903 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding)
1904 { wxPyRaiseNotImplemented(); return NULL; }
1905
1906 bool wxTestFontEncoding(const wxNativeEncodingInfo& info)
1907 { wxPyRaiseNotImplemented(); return false; }
1908
1909 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1910 wxFontEncoding alt_enc;
1911 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1912 return PyInt_FromLong(alt_enc);
1913 else {
1914 Py_INCREF(Py_None);
1915 return Py_None;
1916 }
1917 }
1918 static wxFont *new_wxFont(wxString const &info){
1919 wxNativeFontInfo nfi;
1920 nfi.FromString(info);
1921 return new wxFont(nfi);
1922 }
1923 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1924 return wxFont::New(pointSize, family, flags, face, encoding);
1925 }
1926 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1927 return wxFontBase::New(pixelSize, family,
1928 style, weight, underlined,
1929 face, encoding);
1930 }
1931 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1932 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1933
1934 class wxPyFontEnumerator : public wxFontEnumerator {
1935 public:
1936 wxPyFontEnumerator() {}
1937 ~wxPyFontEnumerator() {}
1938
1939 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1940 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1941
1942 PYPRIVATE;
1943 };
1944
1945 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
1946 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
1947
1948
1949 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
1950 wxArrayString* arr = self->GetEncodings();
1951 if (arr)
1952 return wxArrayString2PyList_helper(*arr);
1953 else
1954 return PyList_New(0);
1955 }
1956 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
1957 wxArrayString* arr = self->GetFacenames();
1958 if (arr)
1959 return wxArrayString2PyList_helper(*arr);
1960 else
1961 return PyList_New(0);
1962 }
1963
1964 #include <locale.h>
1965
1966 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1967 wxLocale* loc;
1968 if (language == -1)
1969 loc = new wxLocale();
1970 else
1971 loc = new wxLocale(language, flags);
1972 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1973 // for the floating point conversions and such to work right.
1974 #if PY_VERSION_HEX < 0x02040000
1975 setlocale(LC_NUMERIC, "C");
1976 #endif
1977 return loc;
1978 }
1979 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
1980 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
1981 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1982 // for the floating point conversions and such to work right.
1983 #if PY_VERSION_HEX < 0x02040000
1984 setlocale(LC_NUMERIC, "C");
1985 #endif
1986 return rc;
1987 }
1988 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1989 bool rc = self->Init(language, flags);
1990 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1991 // for the floating point conversions and such to work right.
1992 #if PY_VERSION_HEX < 0x02040000
1993 setlocale(LC_NUMERIC, "C");
1994 #endif
1995 return rc;
1996 }
1997
1998 #include "wx/wxPython/pydrawxxx.h"
1999
2000 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2001 wxColour col;
2002 self->GetPixel(x, y, &col);
2003 return col;
2004 }
2005 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2006 wxColour col;
2007 self->GetPixel(pt, &col);
2008 return col;
2009 }
2010
2011 SWIGINTERN int
2012 SWIG_AsVal_double(PyObject *obj, double* val)
2013 {
2014 if (PyNumber_Check(obj)) {
2015 if (val) *val = PyFloat_AsDouble(obj);
2016 return 1;
2017 }
2018 else {
2019 SWIG_type_error("number", obj);
2020 }
2021 return 0;
2022 }
2023
2024
2025 SWIGINTERNSHORT double
2026 SWIG_As_double(PyObject* obj)
2027 {
2028 double v;
2029 if (!SWIG_AsVal_double(obj, &v)) {
2030 /*
2031 this is needed to make valgrind/purify happier.
2032 */
2033 memset((void*)&v, 0, sizeof(double));
2034 }
2035 return v;
2036 }
2037
2038
2039 SWIGINTERNSHORT int
2040 SWIG_Check_double(PyObject* obj)
2041 {
2042 return SWIG_AsVal_double(obj, (double*)0);
2043 }
2044
2045 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2046 wxRect rv;
2047 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2048 return rv;
2049 }
2050
2051 static wxRect wxDC_GetClippingRect(wxDC *self){
2052 wxRect rect;
2053 self->GetClippingBox(rect);
2054 return rect;
2055 }
2056 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2057 wxArrayInt widths;
2058 self->GetPartialTextExtents(text, widths);
2059 return widths;
2060 }
2061
2062 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2063 #define SWIG_From_double PyFloat_FromDouble
2064 /*@@*/
2065
2066
2067 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2068 self->SetLogicalOrigin(point.x, point.y);
2069 }
2070 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2071 self->SetDeviceOrigin(point.x, point.y);
2072 }
2073 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2074 self->CalcBoundingBox(point.x, point.y);
2075 }
2076 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2077 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2078 }
2079 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2080 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2081 }
2082 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2083 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2084 }
2085 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2086 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2087 }
2088 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2089 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2090 }
2091 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2092 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2093 }
2094
2095 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2096 *x1 = dc->MinX();
2097 *y1 = dc->MinY();
2098 *x2 = dc->MaxX();
2099 *y2 = dc->MaxY();
2100 }
2101
2102
2103 #include <wx/dcbuffer.h>
2104
2105
2106 #include <wx/dcps.h>
2107
2108
2109 #include <wx/metafile.h>
2110
2111
2112
2113 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2114 self->AddColour(name, wxColour(red, green, blue));
2115 }
2116
2117 #include <wx/effects.h>
2118
2119 #ifdef __cplusplus
2120 extern "C" {
2121 #endif
2122 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2123 PyObject *resultobj;
2124 wxGDIObject *result;
2125 char *kwnames[] = {
2126 NULL
2127 };
2128
2129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2130 {
2131 if (!wxPyCheckForApp()) SWIG_fail;
2132 PyThreadState* __tstate = wxPyBeginAllowThreads();
2133 result = (wxGDIObject *)new wxGDIObject();
2134
2135 wxPyEndAllowThreads(__tstate);
2136 if (PyErr_Occurred()) SWIG_fail;
2137 }
2138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2139 return resultobj;
2140 fail:
2141 return NULL;
2142 }
2143
2144
2145 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2146 PyObject *resultobj;
2147 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2148 PyObject * obj0 = 0 ;
2149 char *kwnames[] = {
2150 (char *) "self", NULL
2151 };
2152
2153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2155 if (SWIG_arg_fail(1)) SWIG_fail;
2156 {
2157 PyThreadState* __tstate = wxPyBeginAllowThreads();
2158 delete arg1;
2159
2160 wxPyEndAllowThreads(__tstate);
2161 if (PyErr_Occurred()) SWIG_fail;
2162 }
2163 Py_INCREF(Py_None); resultobj = Py_None;
2164 return resultobj;
2165 fail:
2166 return NULL;
2167 }
2168
2169
2170 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2171 PyObject *resultobj;
2172 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2173 bool result;
2174 PyObject * obj0 = 0 ;
2175 char *kwnames[] = {
2176 (char *) "self", NULL
2177 };
2178
2179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2181 if (SWIG_arg_fail(1)) SWIG_fail;
2182 {
2183 PyThreadState* __tstate = wxPyBeginAllowThreads();
2184 result = (bool)(arg1)->GetVisible();
2185
2186 wxPyEndAllowThreads(__tstate);
2187 if (PyErr_Occurred()) SWIG_fail;
2188 }
2189 {
2190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2191 }
2192 return resultobj;
2193 fail:
2194 return NULL;
2195 }
2196
2197
2198 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2199 PyObject *resultobj;
2200 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2201 bool arg2 ;
2202 PyObject * obj0 = 0 ;
2203 PyObject * obj1 = 0 ;
2204 char *kwnames[] = {
2205 (char *) "self",(char *) "visible", NULL
2206 };
2207
2208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2210 if (SWIG_arg_fail(1)) SWIG_fail;
2211 {
2212 arg2 = (bool)(SWIG_As_bool(obj1));
2213 if (SWIG_arg_fail(2)) SWIG_fail;
2214 }
2215 {
2216 PyThreadState* __tstate = wxPyBeginAllowThreads();
2217 (arg1)->SetVisible(arg2);
2218
2219 wxPyEndAllowThreads(__tstate);
2220 if (PyErr_Occurred()) SWIG_fail;
2221 }
2222 Py_INCREF(Py_None); resultobj = Py_None;
2223 return resultobj;
2224 fail:
2225 return NULL;
2226 }
2227
2228
2229 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2230 PyObject *resultobj;
2231 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2232 bool result;
2233 PyObject * obj0 = 0 ;
2234 char *kwnames[] = {
2235 (char *) "self", NULL
2236 };
2237
2238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2240 if (SWIG_arg_fail(1)) SWIG_fail;
2241 {
2242 PyThreadState* __tstate = wxPyBeginAllowThreads();
2243 result = (bool)(arg1)->IsNull();
2244
2245 wxPyEndAllowThreads(__tstate);
2246 if (PyErr_Occurred()) SWIG_fail;
2247 }
2248 {
2249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2250 }
2251 return resultobj;
2252 fail:
2253 return NULL;
2254 }
2255
2256
2257 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2258 PyObject *obj;
2259 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2260 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2261 Py_INCREF(obj);
2262 return Py_BuildValue((char *)"");
2263 }
2264 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2265 PyObject *resultobj;
2266 byte arg1 = (byte) 0 ;
2267 byte arg2 = (byte) 0 ;
2268 byte arg3 = (byte) 0 ;
2269 wxColour *result;
2270 PyObject * obj0 = 0 ;
2271 PyObject * obj1 = 0 ;
2272 PyObject * obj2 = 0 ;
2273 char *kwnames[] = {
2274 (char *) "red",(char *) "green",(char *) "blue", NULL
2275 };
2276
2277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2278 if (obj0) {
2279 {
2280 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2281 if (SWIG_arg_fail(1)) SWIG_fail;
2282 }
2283 }
2284 if (obj1) {
2285 {
2286 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2287 if (SWIG_arg_fail(2)) SWIG_fail;
2288 }
2289 }
2290 if (obj2) {
2291 {
2292 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2293 if (SWIG_arg_fail(3)) SWIG_fail;
2294 }
2295 }
2296 {
2297 PyThreadState* __tstate = wxPyBeginAllowThreads();
2298 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2299
2300 wxPyEndAllowThreads(__tstate);
2301 if (PyErr_Occurred()) SWIG_fail;
2302 }
2303 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2304 return resultobj;
2305 fail:
2306 return NULL;
2307 }
2308
2309
2310 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2311 PyObject *resultobj;
2312 wxString *arg1 = 0 ;
2313 wxColour *result;
2314 bool temp1 = false ;
2315 PyObject * obj0 = 0 ;
2316 char *kwnames[] = {
2317 (char *) "colorName", NULL
2318 };
2319
2320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2321 {
2322 arg1 = wxString_in_helper(obj0);
2323 if (arg1 == NULL) SWIG_fail;
2324 temp1 = true;
2325 }
2326 {
2327 if (!wxPyCheckForApp()) SWIG_fail;
2328 PyThreadState* __tstate = wxPyBeginAllowThreads();
2329 result = (wxColour *)new wxColour((wxString const &)*arg1);
2330
2331 wxPyEndAllowThreads(__tstate);
2332 if (PyErr_Occurred()) SWIG_fail;
2333 }
2334 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2335 {
2336 if (temp1)
2337 delete arg1;
2338 }
2339 return resultobj;
2340 fail:
2341 {
2342 if (temp1)
2343 delete arg1;
2344 }
2345 return NULL;
2346 }
2347
2348
2349 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2350 PyObject *resultobj;
2351 unsigned long arg1 ;
2352 wxColour *result;
2353 PyObject * obj0 = 0 ;
2354 char *kwnames[] = {
2355 (char *) "colRGB", NULL
2356 };
2357
2358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2359 {
2360 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2361 if (SWIG_arg_fail(1)) SWIG_fail;
2362 }
2363 {
2364 PyThreadState* __tstate = wxPyBeginAllowThreads();
2365 result = (wxColour *)new wxColour(arg1);
2366
2367 wxPyEndAllowThreads(__tstate);
2368 if (PyErr_Occurred()) SWIG_fail;
2369 }
2370 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2371 return resultobj;
2372 fail:
2373 return NULL;
2374 }
2375
2376
2377 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2378 PyObject *resultobj;
2379 wxColour *arg1 = (wxColour *) 0 ;
2380 PyObject * obj0 = 0 ;
2381 char *kwnames[] = {
2382 (char *) "self", NULL
2383 };
2384
2385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2387 if (SWIG_arg_fail(1)) SWIG_fail;
2388 {
2389 PyThreadState* __tstate = wxPyBeginAllowThreads();
2390 delete arg1;
2391
2392 wxPyEndAllowThreads(__tstate);
2393 if (PyErr_Occurred()) SWIG_fail;
2394 }
2395 Py_INCREF(Py_None); resultobj = Py_None;
2396 return resultobj;
2397 fail:
2398 return NULL;
2399 }
2400
2401
2402 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2403 PyObject *resultobj;
2404 wxColour *arg1 = (wxColour *) 0 ;
2405 byte result;
2406 PyObject * obj0 = 0 ;
2407 char *kwnames[] = {
2408 (char *) "self", NULL
2409 };
2410
2411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2413 if (SWIG_arg_fail(1)) SWIG_fail;
2414 {
2415 PyThreadState* __tstate = wxPyBeginAllowThreads();
2416 result = (byte)(arg1)->Red();
2417
2418 wxPyEndAllowThreads(__tstate);
2419 if (PyErr_Occurred()) SWIG_fail;
2420 }
2421 {
2422 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2423 }
2424 return resultobj;
2425 fail:
2426 return NULL;
2427 }
2428
2429
2430 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2431 PyObject *resultobj;
2432 wxColour *arg1 = (wxColour *) 0 ;
2433 byte result;
2434 PyObject * obj0 = 0 ;
2435 char *kwnames[] = {
2436 (char *) "self", NULL
2437 };
2438
2439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2441 if (SWIG_arg_fail(1)) SWIG_fail;
2442 {
2443 PyThreadState* __tstate = wxPyBeginAllowThreads();
2444 result = (byte)(arg1)->Green();
2445
2446 wxPyEndAllowThreads(__tstate);
2447 if (PyErr_Occurred()) SWIG_fail;
2448 }
2449 {
2450 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2451 }
2452 return resultobj;
2453 fail:
2454 return NULL;
2455 }
2456
2457
2458 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2459 PyObject *resultobj;
2460 wxColour *arg1 = (wxColour *) 0 ;
2461 byte result;
2462 PyObject * obj0 = 0 ;
2463 char *kwnames[] = {
2464 (char *) "self", NULL
2465 };
2466
2467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2469 if (SWIG_arg_fail(1)) SWIG_fail;
2470 {
2471 PyThreadState* __tstate = wxPyBeginAllowThreads();
2472 result = (byte)(arg1)->Blue();
2473
2474 wxPyEndAllowThreads(__tstate);
2475 if (PyErr_Occurred()) SWIG_fail;
2476 }
2477 {
2478 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2479 }
2480 return resultobj;
2481 fail:
2482 return NULL;
2483 }
2484
2485
2486 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2487 PyObject *resultobj;
2488 wxColour *arg1 = (wxColour *) 0 ;
2489 bool result;
2490 PyObject * obj0 = 0 ;
2491 char *kwnames[] = {
2492 (char *) "self", NULL
2493 };
2494
2495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2497 if (SWIG_arg_fail(1)) SWIG_fail;
2498 {
2499 PyThreadState* __tstate = wxPyBeginAllowThreads();
2500 result = (bool)(arg1)->Ok();
2501
2502 wxPyEndAllowThreads(__tstate);
2503 if (PyErr_Occurred()) SWIG_fail;
2504 }
2505 {
2506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2507 }
2508 return resultobj;
2509 fail:
2510 return NULL;
2511 }
2512
2513
2514 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2515 PyObject *resultobj;
2516 wxColour *arg1 = (wxColour *) 0 ;
2517 byte arg2 ;
2518 byte arg3 ;
2519 byte arg4 ;
2520 PyObject * obj0 = 0 ;
2521 PyObject * obj1 = 0 ;
2522 PyObject * obj2 = 0 ;
2523 PyObject * obj3 = 0 ;
2524 char *kwnames[] = {
2525 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2526 };
2527
2528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2530 if (SWIG_arg_fail(1)) SWIG_fail;
2531 {
2532 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2533 if (SWIG_arg_fail(2)) SWIG_fail;
2534 }
2535 {
2536 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2537 if (SWIG_arg_fail(3)) SWIG_fail;
2538 }
2539 {
2540 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2541 if (SWIG_arg_fail(4)) SWIG_fail;
2542 }
2543 {
2544 PyThreadState* __tstate = wxPyBeginAllowThreads();
2545 (arg1)->Set(arg2,arg3,arg4);
2546
2547 wxPyEndAllowThreads(__tstate);
2548 if (PyErr_Occurred()) SWIG_fail;
2549 }
2550 Py_INCREF(Py_None); resultobj = Py_None;
2551 return resultobj;
2552 fail:
2553 return NULL;
2554 }
2555
2556
2557 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2558 PyObject *resultobj;
2559 wxColour *arg1 = (wxColour *) 0 ;
2560 unsigned long arg2 ;
2561 PyObject * obj0 = 0 ;
2562 PyObject * obj1 = 0 ;
2563 char *kwnames[] = {
2564 (char *) "self",(char *) "colRGB", NULL
2565 };
2566
2567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2569 if (SWIG_arg_fail(1)) SWIG_fail;
2570 {
2571 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2572 if (SWIG_arg_fail(2)) SWIG_fail;
2573 }
2574 {
2575 PyThreadState* __tstate = wxPyBeginAllowThreads();
2576 (arg1)->Set(arg2);
2577
2578 wxPyEndAllowThreads(__tstate);
2579 if (PyErr_Occurred()) SWIG_fail;
2580 }
2581 Py_INCREF(Py_None); resultobj = Py_None;
2582 return resultobj;
2583 fail:
2584 return NULL;
2585 }
2586
2587
2588 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2589 PyObject *resultobj;
2590 wxColour *arg1 = (wxColour *) 0 ;
2591 wxString *arg2 = 0 ;
2592 bool temp2 = false ;
2593 PyObject * obj0 = 0 ;
2594 PyObject * obj1 = 0 ;
2595 char *kwnames[] = {
2596 (char *) "self",(char *) "colourName", NULL
2597 };
2598
2599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2601 if (SWIG_arg_fail(1)) SWIG_fail;
2602 {
2603 arg2 = wxString_in_helper(obj1);
2604 if (arg2 == NULL) SWIG_fail;
2605 temp2 = true;
2606 }
2607 {
2608 PyThreadState* __tstate = wxPyBeginAllowThreads();
2609 (arg1)->InitFromName((wxString const &)*arg2);
2610
2611 wxPyEndAllowThreads(__tstate);
2612 if (PyErr_Occurred()) SWIG_fail;
2613 }
2614 Py_INCREF(Py_None); resultobj = Py_None;
2615 {
2616 if (temp2)
2617 delete arg2;
2618 }
2619 return resultobj;
2620 fail:
2621 {
2622 if (temp2)
2623 delete arg2;
2624 }
2625 return NULL;
2626 }
2627
2628
2629 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2630 PyObject *resultobj;
2631 wxColour *arg1 = (wxColour *) 0 ;
2632 long result;
2633 PyObject * obj0 = 0 ;
2634 char *kwnames[] = {
2635 (char *) "self", NULL
2636 };
2637
2638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2640 if (SWIG_arg_fail(1)) SWIG_fail;
2641 {
2642 PyThreadState* __tstate = wxPyBeginAllowThreads();
2643 result = (long)((wxColour const *)arg1)->GetPixel();
2644
2645 wxPyEndAllowThreads(__tstate);
2646 if (PyErr_Occurred()) SWIG_fail;
2647 }
2648 {
2649 resultobj = SWIG_From_long((long)(result));
2650 }
2651 return resultobj;
2652 fail:
2653 return NULL;
2654 }
2655
2656
2657 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2658 PyObject *resultobj;
2659 wxColour *arg1 = (wxColour *) 0 ;
2660 wxColour *arg2 = 0 ;
2661 bool result;
2662 wxColour temp2 ;
2663 PyObject * obj0 = 0 ;
2664 PyObject * obj1 = 0 ;
2665 char *kwnames[] = {
2666 (char *) "self",(char *) "colour", NULL
2667 };
2668
2669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2671 if (SWIG_arg_fail(1)) SWIG_fail;
2672 {
2673 arg2 = &temp2;
2674 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2675 }
2676 {
2677 PyThreadState* __tstate = wxPyBeginAllowThreads();
2678 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2679
2680 wxPyEndAllowThreads(__tstate);
2681 if (PyErr_Occurred()) SWIG_fail;
2682 }
2683 {
2684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2685 }
2686 return resultobj;
2687 fail:
2688 return NULL;
2689 }
2690
2691
2692 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2693 PyObject *resultobj;
2694 wxColour *arg1 = (wxColour *) 0 ;
2695 wxColour *arg2 = 0 ;
2696 bool result;
2697 wxColour temp2 ;
2698 PyObject * obj0 = 0 ;
2699 PyObject * obj1 = 0 ;
2700 char *kwnames[] = {
2701 (char *) "self",(char *) "colour", NULL
2702 };
2703
2704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2706 if (SWIG_arg_fail(1)) SWIG_fail;
2707 {
2708 arg2 = &temp2;
2709 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2710 }
2711 {
2712 PyThreadState* __tstate = wxPyBeginAllowThreads();
2713 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2714
2715 wxPyEndAllowThreads(__tstate);
2716 if (PyErr_Occurred()) SWIG_fail;
2717 }
2718 {
2719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2720 }
2721 return resultobj;
2722 fail:
2723 return NULL;
2724 }
2725
2726
2727 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2728 PyObject *resultobj;
2729 wxColour *arg1 = (wxColour *) 0 ;
2730 PyObject *result;
2731 PyObject * obj0 = 0 ;
2732 char *kwnames[] = {
2733 (char *) "self", NULL
2734 };
2735
2736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2738 if (SWIG_arg_fail(1)) SWIG_fail;
2739 {
2740 PyThreadState* __tstate = wxPyBeginAllowThreads();
2741 result = (PyObject *)wxColour_Get(arg1);
2742
2743 wxPyEndAllowThreads(__tstate);
2744 if (PyErr_Occurred()) SWIG_fail;
2745 }
2746 resultobj = result;
2747 return resultobj;
2748 fail:
2749 return NULL;
2750 }
2751
2752
2753 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2754 PyObject *resultobj;
2755 wxColour *arg1 = (wxColour *) 0 ;
2756 unsigned long result;
2757 PyObject * obj0 = 0 ;
2758 char *kwnames[] = {
2759 (char *) "self", NULL
2760 };
2761
2762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2764 if (SWIG_arg_fail(1)) SWIG_fail;
2765 {
2766 PyThreadState* __tstate = wxPyBeginAllowThreads();
2767 result = (unsigned long)wxColour_GetRGB(arg1);
2768
2769 wxPyEndAllowThreads(__tstate);
2770 if (PyErr_Occurred()) SWIG_fail;
2771 }
2772 {
2773 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2774 }
2775 return resultobj;
2776 fail:
2777 return NULL;
2778 }
2779
2780
2781 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2782 PyObject *obj;
2783 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2784 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2785 Py_INCREF(obj);
2786 return Py_BuildValue((char *)"");
2787 }
2788 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2789 PyObject *resultobj;
2790 int arg1 ;
2791 unsigned char *arg2 = (unsigned char *) 0 ;
2792 unsigned char *arg3 = (unsigned char *) 0 ;
2793 unsigned char *arg4 = (unsigned char *) 0 ;
2794 wxPalette *result;
2795 PyObject * obj0 = 0 ;
2796 PyObject * obj1 = 0 ;
2797 PyObject * obj2 = 0 ;
2798 PyObject * obj3 = 0 ;
2799 char *kwnames[] = {
2800 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2801 };
2802
2803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2804 {
2805 arg1 = (int)(SWIG_As_int(obj0));
2806 if (SWIG_arg_fail(1)) SWIG_fail;
2807 }
2808 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2809 if (SWIG_arg_fail(2)) SWIG_fail;
2810 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2811 if (SWIG_arg_fail(3)) SWIG_fail;
2812 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2813 if (SWIG_arg_fail(4)) SWIG_fail;
2814 {
2815 if (!wxPyCheckForApp()) SWIG_fail;
2816 PyThreadState* __tstate = wxPyBeginAllowThreads();
2817 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2818
2819 wxPyEndAllowThreads(__tstate);
2820 if (PyErr_Occurred()) SWIG_fail;
2821 }
2822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2823 return resultobj;
2824 fail:
2825 return NULL;
2826 }
2827
2828
2829 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2830 PyObject *resultobj;
2831 wxPalette *arg1 = (wxPalette *) 0 ;
2832 PyObject * obj0 = 0 ;
2833 char *kwnames[] = {
2834 (char *) "self", NULL
2835 };
2836
2837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2839 if (SWIG_arg_fail(1)) SWIG_fail;
2840 {
2841 PyThreadState* __tstate = wxPyBeginAllowThreads();
2842 delete arg1;
2843
2844 wxPyEndAllowThreads(__tstate);
2845 if (PyErr_Occurred()) SWIG_fail;
2846 }
2847 Py_INCREF(Py_None); resultobj = Py_None;
2848 return resultobj;
2849 fail:
2850 return NULL;
2851 }
2852
2853
2854 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2855 PyObject *resultobj;
2856 wxPalette *arg1 = (wxPalette *) 0 ;
2857 byte arg2 ;
2858 byte arg3 ;
2859 byte arg4 ;
2860 int result;
2861 PyObject * obj0 = 0 ;
2862 PyObject * obj1 = 0 ;
2863 PyObject * obj2 = 0 ;
2864 PyObject * obj3 = 0 ;
2865 char *kwnames[] = {
2866 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2867 };
2868
2869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2871 if (SWIG_arg_fail(1)) SWIG_fail;
2872 {
2873 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2874 if (SWIG_arg_fail(2)) SWIG_fail;
2875 }
2876 {
2877 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2878 if (SWIG_arg_fail(3)) SWIG_fail;
2879 }
2880 {
2881 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2882 if (SWIG_arg_fail(4)) SWIG_fail;
2883 }
2884 {
2885 PyThreadState* __tstate = wxPyBeginAllowThreads();
2886 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2887
2888 wxPyEndAllowThreads(__tstate);
2889 if (PyErr_Occurred()) SWIG_fail;
2890 }
2891 {
2892 resultobj = SWIG_From_int((int)(result));
2893 }
2894 return resultobj;
2895 fail:
2896 return NULL;
2897 }
2898
2899
2900 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2901 PyObject *resultobj;
2902 wxPalette *arg1 = (wxPalette *) 0 ;
2903 int arg2 ;
2904 byte *arg3 = (byte *) 0 ;
2905 byte *arg4 = (byte *) 0 ;
2906 byte *arg5 = (byte *) 0 ;
2907 bool result;
2908 byte temp3 ;
2909 int res3 = 0 ;
2910 byte temp4 ;
2911 int res4 = 0 ;
2912 byte temp5 ;
2913 int res5 = 0 ;
2914 PyObject * obj0 = 0 ;
2915 PyObject * obj1 = 0 ;
2916 char *kwnames[] = {
2917 (char *) "self",(char *) "pixel", NULL
2918 };
2919
2920 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2921 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2922 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2925 if (SWIG_arg_fail(1)) SWIG_fail;
2926 {
2927 arg2 = (int)(SWIG_As_int(obj1));
2928 if (SWIG_arg_fail(2)) SWIG_fail;
2929 }
2930 {
2931 PyThreadState* __tstate = wxPyBeginAllowThreads();
2932 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2933
2934 wxPyEndAllowThreads(__tstate);
2935 if (PyErr_Occurred()) SWIG_fail;
2936 }
2937 {
2938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2939 }
2940 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2941 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2942 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2943 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2944 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2945 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2946 return resultobj;
2947 fail:
2948 return NULL;
2949 }
2950
2951
2952 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
2953 PyObject *resultobj;
2954 wxPalette *arg1 = (wxPalette *) 0 ;
2955 int result;
2956 PyObject * obj0 = 0 ;
2957 char *kwnames[] = {
2958 (char *) "self", NULL
2959 };
2960
2961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
2962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2963 if (SWIG_arg_fail(1)) SWIG_fail;
2964 {
2965 PyThreadState* __tstate = wxPyBeginAllowThreads();
2966 result = (int)((wxPalette const *)arg1)->GetColoursCount();
2967
2968 wxPyEndAllowThreads(__tstate);
2969 if (PyErr_Occurred()) SWIG_fail;
2970 }
2971 {
2972 resultobj = SWIG_From_int((int)(result));
2973 }
2974 return resultobj;
2975 fail:
2976 return NULL;
2977 }
2978
2979
2980 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2981 PyObject *resultobj;
2982 wxPalette *arg1 = (wxPalette *) 0 ;
2983 bool result;
2984 PyObject * obj0 = 0 ;
2985 char *kwnames[] = {
2986 (char *) "self", NULL
2987 };
2988
2989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
2990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2991 if (SWIG_arg_fail(1)) SWIG_fail;
2992 {
2993 PyThreadState* __tstate = wxPyBeginAllowThreads();
2994 result = (bool)(arg1)->Ok();
2995
2996 wxPyEndAllowThreads(__tstate);
2997 if (PyErr_Occurred()) SWIG_fail;
2998 }
2999 {
3000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3001 }
3002 return resultobj;
3003 fail:
3004 return NULL;
3005 }
3006
3007
3008 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3009 PyObject *obj;
3010 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3011 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3012 Py_INCREF(obj);
3013 return Py_BuildValue((char *)"");
3014 }
3015 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3016 PyObject *resultobj;
3017 wxColour *arg1 = 0 ;
3018 int arg2 = (int) 1 ;
3019 int arg3 = (int) wxSOLID ;
3020 wxPen *result;
3021 wxColour temp1 ;
3022 PyObject * obj0 = 0 ;
3023 PyObject * obj1 = 0 ;
3024 PyObject * obj2 = 0 ;
3025 char *kwnames[] = {
3026 (char *) "colour",(char *) "width",(char *) "style", NULL
3027 };
3028
3029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3030 {
3031 arg1 = &temp1;
3032 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3033 }
3034 if (obj1) {
3035 {
3036 arg2 = (int)(SWIG_As_int(obj1));
3037 if (SWIG_arg_fail(2)) SWIG_fail;
3038 }
3039 }
3040 if (obj2) {
3041 {
3042 arg3 = (int)(SWIG_As_int(obj2));
3043 if (SWIG_arg_fail(3)) SWIG_fail;
3044 }
3045 }
3046 {
3047 if (!wxPyCheckForApp()) SWIG_fail;
3048 PyThreadState* __tstate = wxPyBeginAllowThreads();
3049 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3050
3051 wxPyEndAllowThreads(__tstate);
3052 if (PyErr_Occurred()) SWIG_fail;
3053 }
3054 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3055 return resultobj;
3056 fail:
3057 return NULL;
3058 }
3059
3060
3061 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3062 PyObject *resultobj;
3063 wxPen *arg1 = (wxPen *) 0 ;
3064 PyObject * obj0 = 0 ;
3065 char *kwnames[] = {
3066 (char *) "self", NULL
3067 };
3068
3069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3071 if (SWIG_arg_fail(1)) SWIG_fail;
3072 {
3073 PyThreadState* __tstate = wxPyBeginAllowThreads();
3074 delete arg1;
3075
3076 wxPyEndAllowThreads(__tstate);
3077 if (PyErr_Occurred()) SWIG_fail;
3078 }
3079 Py_INCREF(Py_None); resultobj = Py_None;
3080 return resultobj;
3081 fail:
3082 return NULL;
3083 }
3084
3085
3086 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3087 PyObject *resultobj;
3088 wxPen *arg1 = (wxPen *) 0 ;
3089 int result;
3090 PyObject * obj0 = 0 ;
3091 char *kwnames[] = {
3092 (char *) "self", NULL
3093 };
3094
3095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3097 if (SWIG_arg_fail(1)) SWIG_fail;
3098 {
3099 PyThreadState* __tstate = wxPyBeginAllowThreads();
3100 result = (int)(arg1)->GetCap();
3101
3102 wxPyEndAllowThreads(__tstate);
3103 if (PyErr_Occurred()) SWIG_fail;
3104 }
3105 {
3106 resultobj = SWIG_From_int((int)(result));
3107 }
3108 return resultobj;
3109 fail:
3110 return NULL;
3111 }
3112
3113
3114 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3115 PyObject *resultobj;
3116 wxPen *arg1 = (wxPen *) 0 ;
3117 wxColour result;
3118 PyObject * obj0 = 0 ;
3119 char *kwnames[] = {
3120 (char *) "self", NULL
3121 };
3122
3123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3125 if (SWIG_arg_fail(1)) SWIG_fail;
3126 {
3127 PyThreadState* __tstate = wxPyBeginAllowThreads();
3128 result = (arg1)->GetColour();
3129
3130 wxPyEndAllowThreads(__tstate);
3131 if (PyErr_Occurred()) SWIG_fail;
3132 }
3133 {
3134 wxColour * resultptr;
3135 resultptr = new wxColour((wxColour &)(result));
3136 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3137 }
3138 return resultobj;
3139 fail:
3140 return NULL;
3141 }
3142
3143
3144 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3145 PyObject *resultobj;
3146 wxPen *arg1 = (wxPen *) 0 ;
3147 int result;
3148 PyObject * obj0 = 0 ;
3149 char *kwnames[] = {
3150 (char *) "self", NULL
3151 };
3152
3153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3155 if (SWIG_arg_fail(1)) SWIG_fail;
3156 {
3157 PyThreadState* __tstate = wxPyBeginAllowThreads();
3158 result = (int)(arg1)->GetJoin();
3159
3160 wxPyEndAllowThreads(__tstate);
3161 if (PyErr_Occurred()) SWIG_fail;
3162 }
3163 {
3164 resultobj = SWIG_From_int((int)(result));
3165 }
3166 return resultobj;
3167 fail:
3168 return NULL;
3169 }
3170
3171
3172 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3173 PyObject *resultobj;
3174 wxPen *arg1 = (wxPen *) 0 ;
3175 int result;
3176 PyObject * obj0 = 0 ;
3177 char *kwnames[] = {
3178 (char *) "self", NULL
3179 };
3180
3181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3183 if (SWIG_arg_fail(1)) SWIG_fail;
3184 {
3185 PyThreadState* __tstate = wxPyBeginAllowThreads();
3186 result = (int)(arg1)->GetStyle();
3187
3188 wxPyEndAllowThreads(__tstate);
3189 if (PyErr_Occurred()) SWIG_fail;
3190 }
3191 {
3192 resultobj = SWIG_From_int((int)(result));
3193 }
3194 return resultobj;
3195 fail:
3196 return NULL;
3197 }
3198
3199
3200 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3201 PyObject *resultobj;
3202 wxPen *arg1 = (wxPen *) 0 ;
3203 int result;
3204 PyObject * obj0 = 0 ;
3205 char *kwnames[] = {
3206 (char *) "self", NULL
3207 };
3208
3209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3211 if (SWIG_arg_fail(1)) SWIG_fail;
3212 {
3213 PyThreadState* __tstate = wxPyBeginAllowThreads();
3214 result = (int)(arg1)->GetWidth();
3215
3216 wxPyEndAllowThreads(__tstate);
3217 if (PyErr_Occurred()) SWIG_fail;
3218 }
3219 {
3220 resultobj = SWIG_From_int((int)(result));
3221 }
3222 return resultobj;
3223 fail:
3224 return NULL;
3225 }
3226
3227
3228 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3229 PyObject *resultobj;
3230 wxPen *arg1 = (wxPen *) 0 ;
3231 bool result;
3232 PyObject * obj0 = 0 ;
3233 char *kwnames[] = {
3234 (char *) "self", NULL
3235 };
3236
3237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3239 if (SWIG_arg_fail(1)) SWIG_fail;
3240 {
3241 PyThreadState* __tstate = wxPyBeginAllowThreads();
3242 result = (bool)(arg1)->Ok();
3243
3244 wxPyEndAllowThreads(__tstate);
3245 if (PyErr_Occurred()) SWIG_fail;
3246 }
3247 {
3248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3249 }
3250 return resultobj;
3251 fail:
3252 return NULL;
3253 }
3254
3255
3256 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3257 PyObject *resultobj;
3258 wxPen *arg1 = (wxPen *) 0 ;
3259 int arg2 ;
3260 PyObject * obj0 = 0 ;
3261 PyObject * obj1 = 0 ;
3262 char *kwnames[] = {
3263 (char *) "self",(char *) "cap_style", NULL
3264 };
3265
3266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3268 if (SWIG_arg_fail(1)) SWIG_fail;
3269 {
3270 arg2 = (int)(SWIG_As_int(obj1));
3271 if (SWIG_arg_fail(2)) SWIG_fail;
3272 }
3273 {
3274 PyThreadState* __tstate = wxPyBeginAllowThreads();
3275 (arg1)->SetCap(arg2);
3276
3277 wxPyEndAllowThreads(__tstate);
3278 if (PyErr_Occurred()) SWIG_fail;
3279 }
3280 Py_INCREF(Py_None); resultobj = Py_None;
3281 return resultobj;
3282 fail:
3283 return NULL;
3284 }
3285
3286
3287 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3288 PyObject *resultobj;
3289 wxPen *arg1 = (wxPen *) 0 ;
3290 wxColour *arg2 = 0 ;
3291 wxColour temp2 ;
3292 PyObject * obj0 = 0 ;
3293 PyObject * obj1 = 0 ;
3294 char *kwnames[] = {
3295 (char *) "self",(char *) "colour", NULL
3296 };
3297
3298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3300 if (SWIG_arg_fail(1)) SWIG_fail;
3301 {
3302 arg2 = &temp2;
3303 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3304 }
3305 {
3306 PyThreadState* __tstate = wxPyBeginAllowThreads();
3307 (arg1)->SetColour(*arg2);
3308
3309 wxPyEndAllowThreads(__tstate);
3310 if (PyErr_Occurred()) SWIG_fail;
3311 }
3312 Py_INCREF(Py_None); resultobj = Py_None;
3313 return resultobj;
3314 fail:
3315 return NULL;
3316 }
3317
3318
3319 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3320 PyObject *resultobj;
3321 wxPen *arg1 = (wxPen *) 0 ;
3322 int arg2 ;
3323 PyObject * obj0 = 0 ;
3324 PyObject * obj1 = 0 ;
3325 char *kwnames[] = {
3326 (char *) "self",(char *) "join_style", NULL
3327 };
3328
3329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3331 if (SWIG_arg_fail(1)) SWIG_fail;
3332 {
3333 arg2 = (int)(SWIG_As_int(obj1));
3334 if (SWIG_arg_fail(2)) SWIG_fail;
3335 }
3336 {
3337 PyThreadState* __tstate = wxPyBeginAllowThreads();
3338 (arg1)->SetJoin(arg2);
3339
3340 wxPyEndAllowThreads(__tstate);
3341 if (PyErr_Occurred()) SWIG_fail;
3342 }
3343 Py_INCREF(Py_None); resultobj = Py_None;
3344 return resultobj;
3345 fail:
3346 return NULL;
3347 }
3348
3349
3350 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3351 PyObject *resultobj;
3352 wxPen *arg1 = (wxPen *) 0 ;
3353 int arg2 ;
3354 PyObject * obj0 = 0 ;
3355 PyObject * obj1 = 0 ;
3356 char *kwnames[] = {
3357 (char *) "self",(char *) "style", NULL
3358 };
3359
3360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3362 if (SWIG_arg_fail(1)) SWIG_fail;
3363 {
3364 arg2 = (int)(SWIG_As_int(obj1));
3365 if (SWIG_arg_fail(2)) SWIG_fail;
3366 }
3367 {
3368 PyThreadState* __tstate = wxPyBeginAllowThreads();
3369 (arg1)->SetStyle(arg2);
3370
3371 wxPyEndAllowThreads(__tstate);
3372 if (PyErr_Occurred()) SWIG_fail;
3373 }
3374 Py_INCREF(Py_None); resultobj = Py_None;
3375 return resultobj;
3376 fail:
3377 return NULL;
3378 }
3379
3380
3381 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3382 PyObject *resultobj;
3383 wxPen *arg1 = (wxPen *) 0 ;
3384 int arg2 ;
3385 PyObject * obj0 = 0 ;
3386 PyObject * obj1 = 0 ;
3387 char *kwnames[] = {
3388 (char *) "self",(char *) "width", NULL
3389 };
3390
3391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3393 if (SWIG_arg_fail(1)) SWIG_fail;
3394 {
3395 arg2 = (int)(SWIG_As_int(obj1));
3396 if (SWIG_arg_fail(2)) SWIG_fail;
3397 }
3398 {
3399 PyThreadState* __tstate = wxPyBeginAllowThreads();
3400 (arg1)->SetWidth(arg2);
3401
3402 wxPyEndAllowThreads(__tstate);
3403 if (PyErr_Occurred()) SWIG_fail;
3404 }
3405 Py_INCREF(Py_None); resultobj = Py_None;
3406 return resultobj;
3407 fail:
3408 return NULL;
3409 }
3410
3411
3412 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3413 PyObject *resultobj;
3414 wxPen *arg1 = (wxPen *) 0 ;
3415 int arg2 ;
3416 wxDash *arg3 = (wxDash *) 0 ;
3417 PyObject * obj0 = 0 ;
3418 PyObject * obj1 = 0 ;
3419 char *kwnames[] = {
3420 (char *) "self",(char *) "dashes", NULL
3421 };
3422
3423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3425 if (SWIG_arg_fail(1)) SWIG_fail;
3426 {
3427 arg2 = PyList_Size(obj1);
3428 arg3 = (wxDash*)byte_LIST_helper(obj1);
3429 if (arg3 == NULL) SWIG_fail;
3430 }
3431 {
3432 PyThreadState* __tstate = wxPyBeginAllowThreads();
3433 (arg1)->SetDashes(arg2,arg3);
3434
3435 wxPyEndAllowThreads(__tstate);
3436 if (PyErr_Occurred()) SWIG_fail;
3437 }
3438 Py_INCREF(Py_None); resultobj = Py_None;
3439 {
3440 if (arg3) delete [] arg3;
3441 }
3442 return resultobj;
3443 fail:
3444 {
3445 if (arg3) delete [] arg3;
3446 }
3447 return NULL;
3448 }
3449
3450
3451 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3452 PyObject *resultobj;
3453 wxPen *arg1 = (wxPen *) 0 ;
3454 PyObject *result;
3455 PyObject * obj0 = 0 ;
3456 char *kwnames[] = {
3457 (char *) "self", NULL
3458 };
3459
3460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3462 if (SWIG_arg_fail(1)) SWIG_fail;
3463 {
3464 PyThreadState* __tstate = wxPyBeginAllowThreads();
3465 result = (PyObject *)wxPen_GetDashes(arg1);
3466
3467 wxPyEndAllowThreads(__tstate);
3468 if (PyErr_Occurred()) SWIG_fail;
3469 }
3470 resultobj = result;
3471 return resultobj;
3472 fail:
3473 return NULL;
3474 }
3475
3476
3477 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3478 PyObject *resultobj;
3479 wxPen *arg1 = (wxPen *) 0 ;
3480 PyObject *arg2 = (PyObject *) 0 ;
3481 PyObject *arg3 = (PyObject *) 0 ;
3482 PyObject * obj0 = 0 ;
3483 PyObject * obj1 = 0 ;
3484 PyObject * obj2 = 0 ;
3485 char *kwnames[] = {
3486 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3487 };
3488
3489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3491 if (SWIG_arg_fail(1)) SWIG_fail;
3492 arg2 = obj1;
3493 arg3 = obj2;
3494 {
3495 PyThreadState* __tstate = wxPyBeginAllowThreads();
3496 wxPen__SetDashes(arg1,arg2,arg3);
3497
3498 wxPyEndAllowThreads(__tstate);
3499 if (PyErr_Occurred()) SWIG_fail;
3500 }
3501 Py_INCREF(Py_None); resultobj = Py_None;
3502 return resultobj;
3503 fail:
3504 return NULL;
3505 }
3506
3507
3508 static PyObject *_wrap_Pen_GetDashCount(PyObject *, PyObject *args, PyObject *kwargs) {
3509 PyObject *resultobj;
3510 wxPen *arg1 = (wxPen *) 0 ;
3511 int result;
3512 PyObject * obj0 = 0 ;
3513 char *kwnames[] = {
3514 (char *) "self", NULL
3515 };
3516
3517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashCount",kwnames,&obj0)) goto fail;
3518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3519 if (SWIG_arg_fail(1)) SWIG_fail;
3520 {
3521 PyThreadState* __tstate = wxPyBeginAllowThreads();
3522 result = (int)((wxPen const *)arg1)->GetDashCount();
3523
3524 wxPyEndAllowThreads(__tstate);
3525 if (PyErr_Occurred()) SWIG_fail;
3526 }
3527 {
3528 resultobj = SWIG_From_int((int)(result));
3529 }
3530 return resultobj;
3531 fail:
3532 return NULL;
3533 }
3534
3535
3536 static PyObject *_wrap_Pen_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3537 PyObject *resultobj;
3538 wxPen *arg1 = (wxPen *) 0 ;
3539 wxBitmap *result;
3540 PyObject * obj0 = 0 ;
3541 char *kwnames[] = {
3542 (char *) "self", NULL
3543 };
3544
3545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStipple",kwnames,&obj0)) goto fail;
3546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3547 if (SWIG_arg_fail(1)) SWIG_fail;
3548 {
3549 PyThreadState* __tstate = wxPyBeginAllowThreads();
3550 result = (wxBitmap *)(arg1)->GetStipple();
3551
3552 wxPyEndAllowThreads(__tstate);
3553 if (PyErr_Occurred()) SWIG_fail;
3554 }
3555 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3556 return resultobj;
3557 fail:
3558 return NULL;
3559 }
3560
3561
3562 static PyObject *_wrap_Pen_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3563 PyObject *resultobj;
3564 wxPen *arg1 = (wxPen *) 0 ;
3565 wxBitmap *arg2 = 0 ;
3566 PyObject * obj0 = 0 ;
3567 PyObject * obj1 = 0 ;
3568 char *kwnames[] = {
3569 (char *) "self",(char *) "stipple", NULL
3570 };
3571
3572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3574 if (SWIG_arg_fail(1)) SWIG_fail;
3575 {
3576 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3577 if (SWIG_arg_fail(2)) SWIG_fail;
3578 if (arg2 == NULL) {
3579 SWIG_null_ref("wxBitmap");
3580 }
3581 if (SWIG_arg_fail(2)) SWIG_fail;
3582 }
3583 {
3584 PyThreadState* __tstate = wxPyBeginAllowThreads();
3585 (arg1)->SetStipple(*arg2);
3586
3587 wxPyEndAllowThreads(__tstate);
3588 if (PyErr_Occurred()) SWIG_fail;
3589 }
3590 Py_INCREF(Py_None); resultobj = Py_None;
3591 return resultobj;
3592 fail:
3593 return NULL;
3594 }
3595
3596
3597 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3598 PyObject *resultobj;
3599 wxPen *arg1 = (wxPen *) 0 ;
3600 wxPen *arg2 = (wxPen *) 0 ;
3601 bool result;
3602 PyObject * obj0 = 0 ;
3603 PyObject * obj1 = 0 ;
3604 char *kwnames[] = {
3605 (char *) "self",(char *) "other", NULL
3606 };
3607
3608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3610 if (SWIG_arg_fail(1)) SWIG_fail;
3611 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3612 if (SWIG_arg_fail(2)) SWIG_fail;
3613 {
3614 PyThreadState* __tstate = wxPyBeginAllowThreads();
3615 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3616
3617 wxPyEndAllowThreads(__tstate);
3618 if (PyErr_Occurred()) SWIG_fail;
3619 }
3620 {
3621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3622 }
3623 return resultobj;
3624 fail:
3625 return NULL;
3626 }
3627
3628
3629 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3630 PyObject *resultobj;
3631 wxPen *arg1 = (wxPen *) 0 ;
3632 wxPen *arg2 = (wxPen *) 0 ;
3633 bool result;
3634 PyObject * obj0 = 0 ;
3635 PyObject * obj1 = 0 ;
3636 char *kwnames[] = {
3637 (char *) "self",(char *) "other", NULL
3638 };
3639
3640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3642 if (SWIG_arg_fail(1)) SWIG_fail;
3643 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3644 if (SWIG_arg_fail(2)) SWIG_fail;
3645 {
3646 PyThreadState* __tstate = wxPyBeginAllowThreads();
3647 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3648
3649 wxPyEndAllowThreads(__tstate);
3650 if (PyErr_Occurred()) SWIG_fail;
3651 }
3652 {
3653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3654 }
3655 return resultobj;
3656 fail:
3657 return NULL;
3658 }
3659
3660
3661 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3662 PyObject *obj;
3663 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3664 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3665 Py_INCREF(obj);
3666 return Py_BuildValue((char *)"");
3667 }
3668 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3669 PyObject *resultobj;
3670 wxColour *arg1 = 0 ;
3671 int arg2 = (int) wxSOLID ;
3672 wxBrush *result;
3673 wxColour temp1 ;
3674 PyObject * obj0 = 0 ;
3675 PyObject * obj1 = 0 ;
3676 char *kwnames[] = {
3677 (char *) "colour",(char *) "style", NULL
3678 };
3679
3680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3681 {
3682 arg1 = &temp1;
3683 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3684 }
3685 if (obj1) {
3686 {
3687 arg2 = (int)(SWIG_As_int(obj1));
3688 if (SWIG_arg_fail(2)) SWIG_fail;
3689 }
3690 }
3691 {
3692 if (!wxPyCheckForApp()) SWIG_fail;
3693 PyThreadState* __tstate = wxPyBeginAllowThreads();
3694 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3695
3696 wxPyEndAllowThreads(__tstate);
3697 if (PyErr_Occurred()) SWIG_fail;
3698 }
3699 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3700 return resultobj;
3701 fail:
3702 return NULL;
3703 }
3704
3705
3706 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3707 PyObject *resultobj;
3708 wxBrush *arg1 = (wxBrush *) 0 ;
3709 PyObject * obj0 = 0 ;
3710 char *kwnames[] = {
3711 (char *) "self", NULL
3712 };
3713
3714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3716 if (SWIG_arg_fail(1)) SWIG_fail;
3717 {
3718 PyThreadState* __tstate = wxPyBeginAllowThreads();
3719 delete arg1;
3720
3721 wxPyEndAllowThreads(__tstate);
3722 if (PyErr_Occurred()) SWIG_fail;
3723 }
3724 Py_INCREF(Py_None); resultobj = Py_None;
3725 return resultobj;
3726 fail:
3727 return NULL;
3728 }
3729
3730
3731 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3732 PyObject *resultobj;
3733 wxBrush *arg1 = (wxBrush *) 0 ;
3734 wxColour *arg2 = 0 ;
3735 wxColour temp2 ;
3736 PyObject * obj0 = 0 ;
3737 PyObject * obj1 = 0 ;
3738 char *kwnames[] = {
3739 (char *) "self",(char *) "col", NULL
3740 };
3741
3742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3744 if (SWIG_arg_fail(1)) SWIG_fail;
3745 {
3746 arg2 = &temp2;
3747 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3748 }
3749 {
3750 PyThreadState* __tstate = wxPyBeginAllowThreads();
3751 (arg1)->SetColour((wxColour const &)*arg2);
3752
3753 wxPyEndAllowThreads(__tstate);
3754 if (PyErr_Occurred()) SWIG_fail;
3755 }
3756 Py_INCREF(Py_None); resultobj = Py_None;
3757 return resultobj;
3758 fail:
3759 return NULL;
3760 }
3761
3762
3763 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3764 PyObject *resultobj;
3765 wxBrush *arg1 = (wxBrush *) 0 ;
3766 int arg2 ;
3767 PyObject * obj0 = 0 ;
3768 PyObject * obj1 = 0 ;
3769 char *kwnames[] = {
3770 (char *) "self",(char *) "style", NULL
3771 };
3772
3773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3775 if (SWIG_arg_fail(1)) SWIG_fail;
3776 {
3777 arg2 = (int)(SWIG_As_int(obj1));
3778 if (SWIG_arg_fail(2)) SWIG_fail;
3779 }
3780 {
3781 PyThreadState* __tstate = wxPyBeginAllowThreads();
3782 (arg1)->SetStyle(arg2);
3783
3784 wxPyEndAllowThreads(__tstate);
3785 if (PyErr_Occurred()) SWIG_fail;
3786 }
3787 Py_INCREF(Py_None); resultobj = Py_None;
3788 return resultobj;
3789 fail:
3790 return NULL;
3791 }
3792
3793
3794 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3795 PyObject *resultobj;
3796 wxBrush *arg1 = (wxBrush *) 0 ;
3797 wxBitmap *arg2 = 0 ;
3798 PyObject * obj0 = 0 ;
3799 PyObject * obj1 = 0 ;
3800 char *kwnames[] = {
3801 (char *) "self",(char *) "stipple", NULL
3802 };
3803
3804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3806 if (SWIG_arg_fail(1)) SWIG_fail;
3807 {
3808 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3809 if (SWIG_arg_fail(2)) SWIG_fail;
3810 if (arg2 == NULL) {
3811 SWIG_null_ref("wxBitmap");
3812 }
3813 if (SWIG_arg_fail(2)) SWIG_fail;
3814 }
3815 {
3816 PyThreadState* __tstate = wxPyBeginAllowThreads();
3817 (arg1)->SetStipple((wxBitmap const &)*arg2);
3818
3819 wxPyEndAllowThreads(__tstate);
3820 if (PyErr_Occurred()) SWIG_fail;
3821 }
3822 Py_INCREF(Py_None); resultobj = Py_None;
3823 return resultobj;
3824 fail:
3825 return NULL;
3826 }
3827
3828
3829 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3830 PyObject *resultobj;
3831 wxBrush *arg1 = (wxBrush *) 0 ;
3832 wxColour result;
3833 PyObject * obj0 = 0 ;
3834 char *kwnames[] = {
3835 (char *) "self", NULL
3836 };
3837
3838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3840 if (SWIG_arg_fail(1)) SWIG_fail;
3841 {
3842 PyThreadState* __tstate = wxPyBeginAllowThreads();
3843 result = ((wxBrush const *)arg1)->GetColour();
3844
3845 wxPyEndAllowThreads(__tstate);
3846 if (PyErr_Occurred()) SWIG_fail;
3847 }
3848 {
3849 wxColour * resultptr;
3850 resultptr = new wxColour((wxColour &)(result));
3851 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3852 }
3853 return resultobj;
3854 fail:
3855 return NULL;
3856 }
3857
3858
3859 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3860 PyObject *resultobj;
3861 wxBrush *arg1 = (wxBrush *) 0 ;
3862 int result;
3863 PyObject * obj0 = 0 ;
3864 char *kwnames[] = {
3865 (char *) "self", NULL
3866 };
3867
3868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3870 if (SWIG_arg_fail(1)) SWIG_fail;
3871 {
3872 PyThreadState* __tstate = wxPyBeginAllowThreads();
3873 result = (int)((wxBrush const *)arg1)->GetStyle();
3874
3875 wxPyEndAllowThreads(__tstate);
3876 if (PyErr_Occurred()) SWIG_fail;
3877 }
3878 {
3879 resultobj = SWIG_From_int((int)(result));
3880 }
3881 return resultobj;
3882 fail:
3883 return NULL;
3884 }
3885
3886
3887 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3888 PyObject *resultobj;
3889 wxBrush *arg1 = (wxBrush *) 0 ;
3890 wxBitmap *result;
3891 PyObject * obj0 = 0 ;
3892 char *kwnames[] = {
3893 (char *) "self", NULL
3894 };
3895
3896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3898 if (SWIG_arg_fail(1)) SWIG_fail;
3899 {
3900 PyThreadState* __tstate = wxPyBeginAllowThreads();
3901 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3902
3903 wxPyEndAllowThreads(__tstate);
3904 if (PyErr_Occurred()) SWIG_fail;
3905 }
3906 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3907 return resultobj;
3908 fail:
3909 return NULL;
3910 }
3911
3912
3913 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3914 PyObject *resultobj;
3915 wxBrush *arg1 = (wxBrush *) 0 ;
3916 bool result;
3917 PyObject * obj0 = 0 ;
3918 char *kwnames[] = {
3919 (char *) "self", NULL
3920 };
3921
3922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3924 if (SWIG_arg_fail(1)) SWIG_fail;
3925 {
3926 PyThreadState* __tstate = wxPyBeginAllowThreads();
3927 result = (bool)((wxBrush const *)arg1)->IsHatch();
3928
3929 wxPyEndAllowThreads(__tstate);
3930 if (PyErr_Occurred()) SWIG_fail;
3931 }
3932 {
3933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3934 }
3935 return resultobj;
3936 fail:
3937 return NULL;
3938 }
3939
3940
3941 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3942 PyObject *resultobj;
3943 wxBrush *arg1 = (wxBrush *) 0 ;
3944 bool result;
3945 PyObject * obj0 = 0 ;
3946 char *kwnames[] = {
3947 (char *) "self", NULL
3948 };
3949
3950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3952 if (SWIG_arg_fail(1)) SWIG_fail;
3953 {
3954 PyThreadState* __tstate = wxPyBeginAllowThreads();
3955 result = (bool)(arg1)->Ok();
3956
3957 wxPyEndAllowThreads(__tstate);
3958 if (PyErr_Occurred()) SWIG_fail;
3959 }
3960 {
3961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3962 }
3963 return resultobj;
3964 fail:
3965 return NULL;
3966 }
3967
3968
3969 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
3970 PyObject *obj;
3971 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3972 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
3973 Py_INCREF(obj);
3974 return Py_BuildValue((char *)"");
3975 }
3976 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3977 PyObject *resultobj;
3978 wxString *arg1 = 0 ;
3979 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
3980 wxBitmap *result;
3981 bool temp1 = false ;
3982 PyObject * obj0 = 0 ;
3983 PyObject * obj1 = 0 ;
3984 char *kwnames[] = {
3985 (char *) "name",(char *) "type", NULL
3986 };
3987
3988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
3989 {
3990 arg1 = wxString_in_helper(obj0);
3991 if (arg1 == NULL) SWIG_fail;
3992 temp1 = true;
3993 }
3994 if (obj1) {
3995 {
3996 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
3997 if (SWIG_arg_fail(2)) SWIG_fail;
3998 }
3999 }
4000 {
4001 if (!wxPyCheckForApp()) SWIG_fail;
4002 PyThreadState* __tstate = wxPyBeginAllowThreads();
4003 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
4004
4005 wxPyEndAllowThreads(__tstate);
4006 if (PyErr_Occurred()) SWIG_fail;
4007 }
4008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4009 {
4010 if (temp1)
4011 delete arg1;
4012 }
4013 return resultobj;
4014 fail:
4015 {
4016 if (temp1)
4017 delete arg1;
4018 }
4019 return NULL;
4020 }
4021
4022
4023 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4024 PyObject *resultobj;
4025 wxBitmap *arg1 = (wxBitmap *) 0 ;
4026 PyObject * obj0 = 0 ;
4027 char *kwnames[] = {
4028 (char *) "self", NULL
4029 };
4030
4031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
4032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4033 if (SWIG_arg_fail(1)) SWIG_fail;
4034 {
4035 PyThreadState* __tstate = wxPyBeginAllowThreads();
4036 delete arg1;
4037
4038 wxPyEndAllowThreads(__tstate);
4039 if (PyErr_Occurred()) SWIG_fail;
4040 }
4041 Py_INCREF(Py_None); resultobj = Py_None;
4042 return resultobj;
4043 fail:
4044 return NULL;
4045 }
4046
4047
4048 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4049 PyObject *resultobj;
4050 int arg1 ;
4051 int arg2 ;
4052 int arg3 = (int) -1 ;
4053 wxBitmap *result;
4054 PyObject * obj0 = 0 ;
4055 PyObject * obj1 = 0 ;
4056 PyObject * obj2 = 0 ;
4057 char *kwnames[] = {
4058 (char *) "width",(char *) "height",(char *) "depth", NULL
4059 };
4060
4061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4062 {
4063 arg1 = (int)(SWIG_As_int(obj0));
4064 if (SWIG_arg_fail(1)) SWIG_fail;
4065 }
4066 {
4067 arg2 = (int)(SWIG_As_int(obj1));
4068 if (SWIG_arg_fail(2)) SWIG_fail;
4069 }
4070 if (obj2) {
4071 {
4072 arg3 = (int)(SWIG_As_int(obj2));
4073 if (SWIG_arg_fail(3)) SWIG_fail;
4074 }
4075 }
4076 {
4077 if (!wxPyCheckForApp()) SWIG_fail;
4078 PyThreadState* __tstate = wxPyBeginAllowThreads();
4079 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4080
4081 wxPyEndAllowThreads(__tstate);
4082 if (PyErr_Occurred()) SWIG_fail;
4083 }
4084 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4085 return resultobj;
4086 fail:
4087 return NULL;
4088 }
4089
4090
4091 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4092 PyObject *resultobj;
4093 wxIcon *arg1 = 0 ;
4094 wxBitmap *result;
4095 PyObject * obj0 = 0 ;
4096 char *kwnames[] = {
4097 (char *) "icon", NULL
4098 };
4099
4100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4101 {
4102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4103 if (SWIG_arg_fail(1)) SWIG_fail;
4104 if (arg1 == NULL) {
4105 SWIG_null_ref("wxIcon");
4106 }
4107 if (SWIG_arg_fail(1)) SWIG_fail;
4108 }
4109 {
4110 if (!wxPyCheckForApp()) SWIG_fail;
4111 PyThreadState* __tstate = wxPyBeginAllowThreads();
4112 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4113
4114 wxPyEndAllowThreads(__tstate);
4115 if (PyErr_Occurred()) SWIG_fail;
4116 }
4117 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4118 return resultobj;
4119 fail:
4120 return NULL;
4121 }
4122
4123
4124 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4125 PyObject *resultobj;
4126 wxImage *arg1 = 0 ;
4127 int arg2 = (int) -1 ;
4128 wxBitmap *result;
4129 PyObject * obj0 = 0 ;
4130 PyObject * obj1 = 0 ;
4131 char *kwnames[] = {
4132 (char *) "image",(char *) "depth", NULL
4133 };
4134
4135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4136 {
4137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4138 if (SWIG_arg_fail(1)) SWIG_fail;
4139 if (arg1 == NULL) {
4140 SWIG_null_ref("wxImage");
4141 }
4142 if (SWIG_arg_fail(1)) SWIG_fail;
4143 }
4144 if (obj1) {
4145 {
4146 arg2 = (int)(SWIG_As_int(obj1));
4147 if (SWIG_arg_fail(2)) SWIG_fail;
4148 }
4149 }
4150 {
4151 if (!wxPyCheckForApp()) SWIG_fail;
4152 PyThreadState* __tstate = wxPyBeginAllowThreads();
4153 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4154
4155 wxPyEndAllowThreads(__tstate);
4156 if (PyErr_Occurred()) SWIG_fail;
4157 }
4158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4159 return resultobj;
4160 fail:
4161 return NULL;
4162 }
4163
4164
4165 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4166 PyObject *resultobj;
4167 PyObject *arg1 = (PyObject *) 0 ;
4168 wxBitmap *result;
4169 PyObject * obj0 = 0 ;
4170 char *kwnames[] = {
4171 (char *) "listOfStrings", NULL
4172 };
4173
4174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4175 arg1 = obj0;
4176 {
4177 if (!wxPyCheckForApp()) SWIG_fail;
4178 PyThreadState* __tstate = wxPyBeginAllowThreads();
4179 result = (wxBitmap *)new_wxBitmap(arg1);
4180
4181 wxPyEndAllowThreads(__tstate);
4182 if (PyErr_Occurred()) SWIG_fail;
4183 }
4184 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4185 return resultobj;
4186 fail:
4187 return NULL;
4188 }
4189
4190
4191 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4192 PyObject *resultobj;
4193 PyObject *arg1 = (PyObject *) 0 ;
4194 int arg2 ;
4195 int arg3 ;
4196 int arg4 = (int) 1 ;
4197 wxBitmap *result;
4198 PyObject * obj0 = 0 ;
4199 PyObject * obj1 = 0 ;
4200 PyObject * obj2 = 0 ;
4201 PyObject * obj3 = 0 ;
4202 char *kwnames[] = {
4203 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4204 };
4205
4206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4207 arg1 = obj0;
4208 {
4209 arg2 = (int)(SWIG_As_int(obj1));
4210 if (SWIG_arg_fail(2)) SWIG_fail;
4211 }
4212 {
4213 arg3 = (int)(SWIG_As_int(obj2));
4214 if (SWIG_arg_fail(3)) SWIG_fail;
4215 }
4216 if (obj3) {
4217 {
4218 arg4 = (int)(SWIG_As_int(obj3));
4219 if (SWIG_arg_fail(4)) SWIG_fail;
4220 }
4221 }
4222 {
4223 if (!wxPyCheckForApp()) SWIG_fail;
4224 PyThreadState* __tstate = wxPyBeginAllowThreads();
4225 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4226
4227 wxPyEndAllowThreads(__tstate);
4228 if (PyErr_Occurred()) SWIG_fail;
4229 }
4230 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4231 return resultobj;
4232 fail:
4233 return NULL;
4234 }
4235
4236
4237 static PyObject *_wrap_Bitmap_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
4238 PyObject *resultobj;
4239 wxBitmap *arg1 = (wxBitmap *) 0 ;
4240 long result;
4241 PyObject * obj0 = 0 ;
4242 char *kwnames[] = {
4243 (char *) "self", NULL
4244 };
4245
4246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHandle",kwnames,&obj0)) goto fail;
4247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4248 if (SWIG_arg_fail(1)) SWIG_fail;
4249 {
4250 PyThreadState* __tstate = wxPyBeginAllowThreads();
4251 result = (long)(arg1)->GetHandle();
4252
4253 wxPyEndAllowThreads(__tstate);
4254 if (PyErr_Occurred()) SWIG_fail;
4255 }
4256 {
4257 resultobj = SWIG_From_long((long)(result));
4258 }
4259 return resultobj;
4260 fail:
4261 return NULL;
4262 }
4263
4264
4265 static PyObject *_wrap_Bitmap_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
4266 PyObject *resultobj;
4267 wxBitmap *arg1 = (wxBitmap *) 0 ;
4268 long arg2 ;
4269 PyObject * obj0 = 0 ;
4270 PyObject * obj1 = 0 ;
4271 char *kwnames[] = {
4272 (char *) "self",(char *) "handle", NULL
4273 };
4274
4275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHandle",kwnames,&obj0,&obj1)) goto fail;
4276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4277 if (SWIG_arg_fail(1)) SWIG_fail;
4278 {
4279 arg2 = (long)(SWIG_As_long(obj1));
4280 if (SWIG_arg_fail(2)) SWIG_fail;
4281 }
4282 {
4283 PyThreadState* __tstate = wxPyBeginAllowThreads();
4284 wxBitmap_SetHandle(arg1,arg2);
4285
4286 wxPyEndAllowThreads(__tstate);
4287 if (PyErr_Occurred()) SWIG_fail;
4288 }
4289 Py_INCREF(Py_None); resultobj = Py_None;
4290 return resultobj;
4291 fail:
4292 return NULL;
4293 }
4294
4295
4296 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4297 PyObject *resultobj;
4298 wxBitmap *arg1 = (wxBitmap *) 0 ;
4299 bool result;
4300 PyObject * obj0 = 0 ;
4301 char *kwnames[] = {
4302 (char *) "self", NULL
4303 };
4304
4305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4307 if (SWIG_arg_fail(1)) SWIG_fail;
4308 {
4309 PyThreadState* __tstate = wxPyBeginAllowThreads();
4310 result = (bool)(arg1)->Ok();
4311
4312 wxPyEndAllowThreads(__tstate);
4313 if (PyErr_Occurred()) SWIG_fail;
4314 }
4315 {
4316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4317 }
4318 return resultobj;
4319 fail:
4320 return NULL;
4321 }
4322
4323
4324 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4325 PyObject *resultobj;
4326 wxBitmap *arg1 = (wxBitmap *) 0 ;
4327 int result;
4328 PyObject * obj0 = 0 ;
4329 char *kwnames[] = {
4330 (char *) "self", NULL
4331 };
4332
4333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4335 if (SWIG_arg_fail(1)) SWIG_fail;
4336 {
4337 PyThreadState* __tstate = wxPyBeginAllowThreads();
4338 result = (int)(arg1)->GetWidth();
4339
4340 wxPyEndAllowThreads(__tstate);
4341 if (PyErr_Occurred()) SWIG_fail;
4342 }
4343 {
4344 resultobj = SWIG_From_int((int)(result));
4345 }
4346 return resultobj;
4347 fail:
4348 return NULL;
4349 }
4350
4351
4352 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4353 PyObject *resultobj;
4354 wxBitmap *arg1 = (wxBitmap *) 0 ;
4355 int result;
4356 PyObject * obj0 = 0 ;
4357 char *kwnames[] = {
4358 (char *) "self", NULL
4359 };
4360
4361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4363 if (SWIG_arg_fail(1)) SWIG_fail;
4364 {
4365 PyThreadState* __tstate = wxPyBeginAllowThreads();
4366 result = (int)(arg1)->GetHeight();
4367
4368 wxPyEndAllowThreads(__tstate);
4369 if (PyErr_Occurred()) SWIG_fail;
4370 }
4371 {
4372 resultobj = SWIG_From_int((int)(result));
4373 }
4374 return resultobj;
4375 fail:
4376 return NULL;
4377 }
4378
4379
4380 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4381 PyObject *resultobj;
4382 wxBitmap *arg1 = (wxBitmap *) 0 ;
4383 int result;
4384 PyObject * obj0 = 0 ;
4385 char *kwnames[] = {
4386 (char *) "self", NULL
4387 };
4388
4389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4391 if (SWIG_arg_fail(1)) SWIG_fail;
4392 {
4393 PyThreadState* __tstate = wxPyBeginAllowThreads();
4394 result = (int)(arg1)->GetDepth();
4395
4396 wxPyEndAllowThreads(__tstate);
4397 if (PyErr_Occurred()) SWIG_fail;
4398 }
4399 {
4400 resultobj = SWIG_From_int((int)(result));
4401 }
4402 return resultobj;
4403 fail:
4404 return NULL;
4405 }
4406
4407
4408 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4409 PyObject *resultobj;
4410 wxBitmap *arg1 = (wxBitmap *) 0 ;
4411 wxSize result;
4412 PyObject * obj0 = 0 ;
4413 char *kwnames[] = {
4414 (char *) "self", NULL
4415 };
4416
4417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4419 if (SWIG_arg_fail(1)) SWIG_fail;
4420 {
4421 PyThreadState* __tstate = wxPyBeginAllowThreads();
4422 result = wxBitmap_GetSize(arg1);
4423
4424 wxPyEndAllowThreads(__tstate);
4425 if (PyErr_Occurred()) SWIG_fail;
4426 }
4427 {
4428 wxSize * resultptr;
4429 resultptr = new wxSize((wxSize &)(result));
4430 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4431 }
4432 return resultobj;
4433 fail:
4434 return NULL;
4435 }
4436
4437
4438 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4439 PyObject *resultobj;
4440 wxBitmap *arg1 = (wxBitmap *) 0 ;
4441 SwigValueWrapper<wxImage > result;
4442 PyObject * obj0 = 0 ;
4443 char *kwnames[] = {
4444 (char *) "self", NULL
4445 };
4446
4447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4449 if (SWIG_arg_fail(1)) SWIG_fail;
4450 {
4451 PyThreadState* __tstate = wxPyBeginAllowThreads();
4452 result = ((wxBitmap const *)arg1)->ConvertToImage();
4453
4454 wxPyEndAllowThreads(__tstate);
4455 if (PyErr_Occurred()) SWIG_fail;
4456 }
4457 {
4458 wxImage * resultptr;
4459 resultptr = new wxImage((wxImage &)(result));
4460 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4461 }
4462 return resultobj;
4463 fail:
4464 return NULL;
4465 }
4466
4467
4468 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4469 PyObject *resultobj;
4470 wxBitmap *arg1 = (wxBitmap *) 0 ;
4471 wxMask *result;
4472 PyObject * obj0 = 0 ;
4473 char *kwnames[] = {
4474 (char *) "self", NULL
4475 };
4476
4477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4479 if (SWIG_arg_fail(1)) SWIG_fail;
4480 {
4481 PyThreadState* __tstate = wxPyBeginAllowThreads();
4482 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4483
4484 wxPyEndAllowThreads(__tstate);
4485 if (PyErr_Occurred()) SWIG_fail;
4486 }
4487 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4488 return resultobj;
4489 fail:
4490 return NULL;
4491 }
4492
4493
4494 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4495 PyObject *resultobj;
4496 wxBitmap *arg1 = (wxBitmap *) 0 ;
4497 wxMask *arg2 = (wxMask *) 0 ;
4498 PyObject * obj0 = 0 ;
4499 PyObject * obj1 = 0 ;
4500 char *kwnames[] = {
4501 (char *) "self",(char *) "mask", NULL
4502 };
4503
4504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4506 if (SWIG_arg_fail(1)) SWIG_fail;
4507 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4508 if (SWIG_arg_fail(2)) SWIG_fail;
4509 {
4510 PyThreadState* __tstate = wxPyBeginAllowThreads();
4511 (arg1)->SetMask(arg2);
4512
4513 wxPyEndAllowThreads(__tstate);
4514 if (PyErr_Occurred()) SWIG_fail;
4515 }
4516 Py_INCREF(Py_None); resultobj = Py_None;
4517 return resultobj;
4518 fail:
4519 return NULL;
4520 }
4521
4522
4523 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4524 PyObject *resultobj;
4525 wxBitmap *arg1 = (wxBitmap *) 0 ;
4526 wxColour *arg2 = 0 ;
4527 wxColour temp2 ;
4528 PyObject * obj0 = 0 ;
4529 PyObject * obj1 = 0 ;
4530 char *kwnames[] = {
4531 (char *) "self",(char *) "colour", NULL
4532 };
4533
4534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4536 if (SWIG_arg_fail(1)) SWIG_fail;
4537 {
4538 arg2 = &temp2;
4539 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4540 }
4541 {
4542 PyThreadState* __tstate = wxPyBeginAllowThreads();
4543 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4544
4545 wxPyEndAllowThreads(__tstate);
4546 if (PyErr_Occurred()) SWIG_fail;
4547 }
4548 Py_INCREF(Py_None); resultobj = Py_None;
4549 return resultobj;
4550 fail:
4551 return NULL;
4552 }
4553
4554
4555 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4556 PyObject *resultobj;
4557 wxBitmap *arg1 = (wxBitmap *) 0 ;
4558 wxRect *arg2 = 0 ;
4559 SwigValueWrapper<wxBitmap > result;
4560 wxRect temp2 ;
4561 PyObject * obj0 = 0 ;
4562 PyObject * obj1 = 0 ;
4563 char *kwnames[] = {
4564 (char *) "self",(char *) "rect", NULL
4565 };
4566
4567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4569 if (SWIG_arg_fail(1)) SWIG_fail;
4570 {
4571 arg2 = &temp2;
4572 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4573 }
4574 {
4575 PyThreadState* __tstate = wxPyBeginAllowThreads();
4576 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4577
4578 wxPyEndAllowThreads(__tstate);
4579 if (PyErr_Occurred()) SWIG_fail;
4580 }
4581 {
4582 wxBitmap * resultptr;
4583 resultptr = new wxBitmap((wxBitmap &)(result));
4584 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4585 }
4586 return resultobj;
4587 fail:
4588 return NULL;
4589 }
4590
4591
4592 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4593 PyObject *resultobj;
4594 wxBitmap *arg1 = (wxBitmap *) 0 ;
4595 wxString *arg2 = 0 ;
4596 wxBitmapType arg3 ;
4597 wxPalette *arg4 = (wxPalette *) NULL ;
4598 bool result;
4599 bool temp2 = false ;
4600 PyObject * obj0 = 0 ;
4601 PyObject * obj1 = 0 ;
4602 PyObject * obj2 = 0 ;
4603 PyObject * obj3 = 0 ;
4604 char *kwnames[] = {
4605 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4606 };
4607
4608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4610 if (SWIG_arg_fail(1)) SWIG_fail;
4611 {
4612 arg2 = wxString_in_helper(obj1);
4613 if (arg2 == NULL) SWIG_fail;
4614 temp2 = true;
4615 }
4616 {
4617 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4618 if (SWIG_arg_fail(3)) SWIG_fail;
4619 }
4620 if (obj3) {
4621 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4622 if (SWIG_arg_fail(4)) SWIG_fail;
4623 }
4624 {
4625 PyThreadState* __tstate = wxPyBeginAllowThreads();
4626 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4627
4628 wxPyEndAllowThreads(__tstate);
4629 if (PyErr_Occurred()) SWIG_fail;
4630 }
4631 {
4632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4633 }
4634 {
4635 if (temp2)
4636 delete arg2;
4637 }
4638 return resultobj;
4639 fail:
4640 {
4641 if (temp2)
4642 delete arg2;
4643 }
4644 return NULL;
4645 }
4646
4647
4648 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4649 PyObject *resultobj;
4650 wxBitmap *arg1 = (wxBitmap *) 0 ;
4651 wxString *arg2 = 0 ;
4652 wxBitmapType arg3 ;
4653 bool result;
4654 bool temp2 = false ;
4655 PyObject * obj0 = 0 ;
4656 PyObject * obj1 = 0 ;
4657 PyObject * obj2 = 0 ;
4658 char *kwnames[] = {
4659 (char *) "self",(char *) "name",(char *) "type", NULL
4660 };
4661
4662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4664 if (SWIG_arg_fail(1)) SWIG_fail;
4665 {
4666 arg2 = wxString_in_helper(obj1);
4667 if (arg2 == NULL) SWIG_fail;
4668 temp2 = true;
4669 }
4670 {
4671 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4672 if (SWIG_arg_fail(3)) SWIG_fail;
4673 }
4674 {
4675 PyThreadState* __tstate = wxPyBeginAllowThreads();
4676 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4677
4678 wxPyEndAllowThreads(__tstate);
4679 if (PyErr_Occurred()) SWIG_fail;
4680 }
4681 {
4682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4683 }
4684 {
4685 if (temp2)
4686 delete arg2;
4687 }
4688 return resultobj;
4689 fail:
4690 {
4691 if (temp2)
4692 delete arg2;
4693 }
4694 return NULL;
4695 }
4696
4697
4698 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4699 PyObject *resultobj;
4700 wxBitmap *arg1 = (wxBitmap *) 0 ;
4701 wxPalette *result;
4702 PyObject * obj0 = 0 ;
4703 char *kwnames[] = {
4704 (char *) "self", NULL
4705 };
4706
4707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4709 if (SWIG_arg_fail(1)) SWIG_fail;
4710 {
4711 PyThreadState* __tstate = wxPyBeginAllowThreads();
4712 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4713
4714 wxPyEndAllowThreads(__tstate);
4715 if (PyErr_Occurred()) SWIG_fail;
4716 }
4717 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4718 return resultobj;
4719 fail:
4720 return NULL;
4721 }
4722
4723
4724 static PyObject *_wrap_Bitmap_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4725 PyObject *resultobj;
4726 wxBitmap *arg1 = (wxBitmap *) 0 ;
4727 wxPalette *arg2 = 0 ;
4728 PyObject * obj0 = 0 ;
4729 PyObject * obj1 = 0 ;
4730 char *kwnames[] = {
4731 (char *) "self",(char *) "palette", NULL
4732 };
4733
4734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetPalette",kwnames,&obj0,&obj1)) goto fail;
4735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4736 if (SWIG_arg_fail(1)) SWIG_fail;
4737 {
4738 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4739 if (SWIG_arg_fail(2)) SWIG_fail;
4740 if (arg2 == NULL) {
4741 SWIG_null_ref("wxPalette");
4742 }
4743 if (SWIG_arg_fail(2)) SWIG_fail;
4744 }
4745 {
4746 PyThreadState* __tstate = wxPyBeginAllowThreads();
4747 (arg1)->SetPalette((wxPalette const &)*arg2);
4748
4749 wxPyEndAllowThreads(__tstate);
4750 if (PyErr_Occurred()) SWIG_fail;
4751 }
4752 Py_INCREF(Py_None); resultobj = Py_None;
4753 return resultobj;
4754 fail:
4755 return NULL;
4756 }
4757
4758
4759 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4760 PyObject *resultobj;
4761 wxBitmap *arg1 = (wxBitmap *) 0 ;
4762 wxIcon *arg2 = 0 ;
4763 bool result;
4764 PyObject * obj0 = 0 ;
4765 PyObject * obj1 = 0 ;
4766 char *kwnames[] = {
4767 (char *) "self",(char *) "icon", NULL
4768 };
4769
4770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4772 if (SWIG_arg_fail(1)) SWIG_fail;
4773 {
4774 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4775 if (SWIG_arg_fail(2)) SWIG_fail;
4776 if (arg2 == NULL) {
4777 SWIG_null_ref("wxIcon");
4778 }
4779 if (SWIG_arg_fail(2)) SWIG_fail;
4780 }
4781 {
4782 PyThreadState* __tstate = wxPyBeginAllowThreads();
4783 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4784
4785 wxPyEndAllowThreads(__tstate);
4786 if (PyErr_Occurred()) SWIG_fail;
4787 }
4788 {
4789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4790 }
4791 return resultobj;
4792 fail:
4793 return NULL;
4794 }
4795
4796
4797 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4798 PyObject *resultobj;
4799 wxBitmap *arg1 = (wxBitmap *) 0 ;
4800 int arg2 ;
4801 PyObject * obj0 = 0 ;
4802 PyObject * obj1 = 0 ;
4803 char *kwnames[] = {
4804 (char *) "self",(char *) "height", NULL
4805 };
4806
4807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4809 if (SWIG_arg_fail(1)) SWIG_fail;
4810 {
4811 arg2 = (int)(SWIG_As_int(obj1));
4812 if (SWIG_arg_fail(2)) SWIG_fail;
4813 }
4814 {
4815 PyThreadState* __tstate = wxPyBeginAllowThreads();
4816 (arg1)->SetHeight(arg2);
4817
4818 wxPyEndAllowThreads(__tstate);
4819 if (PyErr_Occurred()) SWIG_fail;
4820 }
4821 Py_INCREF(Py_None); resultobj = Py_None;
4822 return resultobj;
4823 fail:
4824 return NULL;
4825 }
4826
4827
4828 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4829 PyObject *resultobj;
4830 wxBitmap *arg1 = (wxBitmap *) 0 ;
4831 int arg2 ;
4832 PyObject * obj0 = 0 ;
4833 PyObject * obj1 = 0 ;
4834 char *kwnames[] = {
4835 (char *) "self",(char *) "width", NULL
4836 };
4837
4838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4840 if (SWIG_arg_fail(1)) SWIG_fail;
4841 {
4842 arg2 = (int)(SWIG_As_int(obj1));
4843 if (SWIG_arg_fail(2)) SWIG_fail;
4844 }
4845 {
4846 PyThreadState* __tstate = wxPyBeginAllowThreads();
4847 (arg1)->SetWidth(arg2);
4848
4849 wxPyEndAllowThreads(__tstate);
4850 if (PyErr_Occurred()) SWIG_fail;
4851 }
4852 Py_INCREF(Py_None); resultobj = Py_None;
4853 return resultobj;
4854 fail:
4855 return NULL;
4856 }
4857
4858
4859 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4860 PyObject *resultobj;
4861 wxBitmap *arg1 = (wxBitmap *) 0 ;
4862 int arg2 ;
4863 PyObject * obj0 = 0 ;
4864 PyObject * obj1 = 0 ;
4865 char *kwnames[] = {
4866 (char *) "self",(char *) "depth", NULL
4867 };
4868
4869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4871 if (SWIG_arg_fail(1)) SWIG_fail;
4872 {
4873 arg2 = (int)(SWIG_As_int(obj1));
4874 if (SWIG_arg_fail(2)) SWIG_fail;
4875 }
4876 {
4877 PyThreadState* __tstate = wxPyBeginAllowThreads();
4878 (arg1)->SetDepth(arg2);
4879
4880 wxPyEndAllowThreads(__tstate);
4881 if (PyErr_Occurred()) SWIG_fail;
4882 }
4883 Py_INCREF(Py_None); resultobj = Py_None;
4884 return resultobj;
4885 fail:
4886 return NULL;
4887 }
4888
4889
4890 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4891 PyObject *resultobj;
4892 wxBitmap *arg1 = (wxBitmap *) 0 ;
4893 wxSize *arg2 = 0 ;
4894 wxSize temp2 ;
4895 PyObject * obj0 = 0 ;
4896 PyObject * obj1 = 0 ;
4897 char *kwnames[] = {
4898 (char *) "self",(char *) "size", NULL
4899 };
4900
4901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4903 if (SWIG_arg_fail(1)) SWIG_fail;
4904 {
4905 arg2 = &temp2;
4906 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4907 }
4908 {
4909 PyThreadState* __tstate = wxPyBeginAllowThreads();
4910 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4911
4912 wxPyEndAllowThreads(__tstate);
4913 if (PyErr_Occurred()) SWIG_fail;
4914 }
4915 Py_INCREF(Py_None); resultobj = Py_None;
4916 return resultobj;
4917 fail:
4918 return NULL;
4919 }
4920
4921
4922 static PyObject *_wrap_Bitmap_CopyFromCursor(PyObject *, PyObject *args, PyObject *kwargs) {
4923 PyObject *resultobj;
4924 wxBitmap *arg1 = (wxBitmap *) 0 ;
4925 wxCursor *arg2 = 0 ;
4926 bool result;
4927 PyObject * obj0 = 0 ;
4928 PyObject * obj1 = 0 ;
4929 char *kwnames[] = {
4930 (char *) "self",(char *) "cursor", NULL
4931 };
4932
4933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromCursor",kwnames,&obj0,&obj1)) goto fail;
4934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4935 if (SWIG_arg_fail(1)) SWIG_fail;
4936 {
4937 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
4938 if (SWIG_arg_fail(2)) SWIG_fail;
4939 if (arg2 == NULL) {
4940 SWIG_null_ref("wxCursor");
4941 }
4942 if (SWIG_arg_fail(2)) SWIG_fail;
4943 }
4944 {
4945 PyThreadState* __tstate = wxPyBeginAllowThreads();
4946 result = (bool)(arg1)->CopyFromCursor((wxCursor const &)*arg2);
4947
4948 wxPyEndAllowThreads(__tstate);
4949 if (PyErr_Occurred()) SWIG_fail;
4950 }
4951 {
4952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4953 }
4954 return resultobj;
4955 fail:
4956 return NULL;
4957 }
4958
4959
4960 static PyObject *_wrap_Bitmap_GetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
4961 PyObject *resultobj;
4962 wxBitmap *arg1 = (wxBitmap *) 0 ;
4963 int result;
4964 PyObject * obj0 = 0 ;
4965 char *kwnames[] = {
4966 (char *) "self", NULL
4967 };
4968
4969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetQuality",kwnames,&obj0)) goto fail;
4970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4971 if (SWIG_arg_fail(1)) SWIG_fail;
4972 {
4973 PyThreadState* __tstate = wxPyBeginAllowThreads();
4974 result = (int)(arg1)->GetQuality();
4975
4976 wxPyEndAllowThreads(__tstate);
4977 if (PyErr_Occurred()) SWIG_fail;
4978 }
4979 {
4980 resultobj = SWIG_From_int((int)(result));
4981 }
4982 return resultobj;
4983 fail:
4984 return NULL;
4985 }
4986
4987
4988 static PyObject *_wrap_Bitmap_SetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
4989 PyObject *resultobj;
4990 wxBitmap *arg1 = (wxBitmap *) 0 ;
4991 int arg2 ;
4992 PyObject * obj0 = 0 ;
4993 PyObject * obj1 = 0 ;
4994 char *kwnames[] = {
4995 (char *) "self",(char *) "q", NULL
4996 };
4997
4998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetQuality",kwnames,&obj0,&obj1)) goto fail;
4999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5000 if (SWIG_arg_fail(1)) SWIG_fail;
5001 {
5002 arg2 = (int)(SWIG_As_int(obj1));
5003 if (SWIG_arg_fail(2)) SWIG_fail;
5004 }
5005 {
5006 PyThreadState* __tstate = wxPyBeginAllowThreads();
5007 (arg1)->SetQuality(arg2);
5008
5009 wxPyEndAllowThreads(__tstate);
5010 if (PyErr_Occurred()) SWIG_fail;
5011 }
5012 Py_INCREF(Py_None); resultobj = Py_None;
5013 return resultobj;
5014 fail:
5015 return NULL;
5016 }
5017
5018
5019 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5020 PyObject *resultobj;
5021 wxBitmap *arg1 = (wxBitmap *) 0 ;
5022 wxBitmap *arg2 = (wxBitmap *) 0 ;
5023 bool result;
5024 PyObject * obj0 = 0 ;
5025 PyObject * obj1 = 0 ;
5026 char *kwnames[] = {
5027 (char *) "self",(char *) "other", NULL
5028 };
5029
5030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
5031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5032 if (SWIG_arg_fail(1)) SWIG_fail;
5033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5034 if (SWIG_arg_fail(2)) SWIG_fail;
5035 {
5036 PyThreadState* __tstate = wxPyBeginAllowThreads();
5037 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
5038
5039 wxPyEndAllowThreads(__tstate);
5040 if (PyErr_Occurred()) SWIG_fail;
5041 }
5042 {
5043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5044 }
5045 return resultobj;
5046 fail:
5047 return NULL;
5048 }
5049
5050
5051 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5052 PyObject *resultobj;
5053 wxBitmap *arg1 = (wxBitmap *) 0 ;
5054 wxBitmap *arg2 = (wxBitmap *) 0 ;
5055 bool result;
5056 PyObject * obj0 = 0 ;
5057 PyObject * obj1 = 0 ;
5058 char *kwnames[] = {
5059 (char *) "self",(char *) "other", NULL
5060 };
5061
5062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
5063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5064 if (SWIG_arg_fail(1)) SWIG_fail;
5065 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5066 if (SWIG_arg_fail(2)) SWIG_fail;
5067 {
5068 PyThreadState* __tstate = wxPyBeginAllowThreads();
5069 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
5070
5071 wxPyEndAllowThreads(__tstate);
5072 if (PyErr_Occurred()) SWIG_fail;
5073 }
5074 {
5075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5076 }
5077 return resultobj;
5078 fail:
5079 return NULL;
5080 }
5081
5082
5083 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
5084 PyObject *obj;
5085 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5086 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
5087 Py_INCREF(obj);
5088 return Py_BuildValue((char *)"");
5089 }
5090 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
5091 PyObject *resultobj;
5092 wxBitmap *arg1 = 0 ;
5093 wxColour const &arg2_defvalue = wxNullColour ;
5094 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
5095 wxMask *result;
5096 wxColour temp2 ;
5097 PyObject * obj0 = 0 ;
5098 PyObject * obj1 = 0 ;
5099 char *kwnames[] = {
5100 (char *) "bitmap",(char *) "colour", NULL
5101 };
5102
5103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
5104 {
5105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5106 if (SWIG_arg_fail(1)) SWIG_fail;
5107 if (arg1 == NULL) {
5108 SWIG_null_ref("wxBitmap");
5109 }
5110 if (SWIG_arg_fail(1)) SWIG_fail;
5111 }
5112 if (obj1) {
5113 {
5114 arg2 = &temp2;
5115 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5116 }
5117 }
5118 {
5119 if (!wxPyCheckForApp()) SWIG_fail;
5120 PyThreadState* __tstate = wxPyBeginAllowThreads();
5121 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
5122
5123 wxPyEndAllowThreads(__tstate);
5124 if (PyErr_Occurred()) SWIG_fail;
5125 }
5126 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
5127 return resultobj;
5128 fail:
5129 return NULL;
5130 }
5131
5132
5133 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
5134 PyObject *obj;
5135 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5136 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
5137 Py_INCREF(obj);
5138 return Py_BuildValue((char *)"");
5139 }
5140 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5141 PyObject *resultobj;
5142 wxString *arg1 = 0 ;
5143 wxBitmapType arg2 ;
5144 int arg3 = (int) -1 ;
5145 int arg4 = (int) -1 ;
5146 wxIcon *result;
5147 bool temp1 = false ;
5148 PyObject * obj0 = 0 ;
5149 PyObject * obj1 = 0 ;
5150 PyObject * obj2 = 0 ;
5151 PyObject * obj3 = 0 ;
5152 char *kwnames[] = {
5153 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
5154 };
5155
5156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5157 {
5158 arg1 = wxString_in_helper(obj0);
5159 if (arg1 == NULL) SWIG_fail;
5160 temp1 = true;
5161 }
5162 {
5163 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
5164 if (SWIG_arg_fail(2)) SWIG_fail;
5165 }
5166 if (obj2) {
5167 {
5168 arg3 = (int)(SWIG_As_int(obj2));
5169 if (SWIG_arg_fail(3)) SWIG_fail;
5170 }
5171 }
5172 if (obj3) {
5173 {
5174 arg4 = (int)(SWIG_As_int(obj3));
5175 if (SWIG_arg_fail(4)) SWIG_fail;
5176 }
5177 }
5178 {
5179 if (!wxPyCheckForApp()) SWIG_fail;
5180 PyThreadState* __tstate = wxPyBeginAllowThreads();
5181 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
5182
5183 wxPyEndAllowThreads(__tstate);
5184 if (PyErr_Occurred()) SWIG_fail;
5185 }
5186 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5187 {
5188 if (temp1)
5189 delete arg1;
5190 }
5191 return resultobj;
5192 fail:
5193 {
5194 if (temp1)
5195 delete arg1;
5196 }
5197 return NULL;
5198 }
5199
5200
5201 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5202 PyObject *resultobj;
5203 wxIcon *arg1 = (wxIcon *) 0 ;
5204 PyObject * obj0 = 0 ;
5205 char *kwnames[] = {
5206 (char *) "self", NULL
5207 };
5208
5209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
5210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5211 if (SWIG_arg_fail(1)) SWIG_fail;
5212 {
5213 PyThreadState* __tstate = wxPyBeginAllowThreads();
5214 delete arg1;
5215
5216 wxPyEndAllowThreads(__tstate);
5217 if (PyErr_Occurred()) SWIG_fail;
5218 }
5219 Py_INCREF(Py_None); resultobj = Py_None;
5220 return resultobj;
5221 fail:
5222 return NULL;
5223 }
5224
5225
5226 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5227 PyObject *resultobj;
5228 wxIcon *result;
5229 char *kwnames[] = {
5230 NULL
5231 };
5232
5233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5234 {
5235 if (!wxPyCheckForApp()) SWIG_fail;
5236 PyThreadState* __tstate = wxPyBeginAllowThreads();
5237 result = (wxIcon *)new wxIcon();
5238
5239 wxPyEndAllowThreads(__tstate);
5240 if (PyErr_Occurred()) SWIG_fail;
5241 }
5242 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5243 return resultobj;
5244 fail:
5245 return NULL;
5246 }
5247
5248
5249 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5250 PyObject *resultobj;
5251 wxIconLocation *arg1 = 0 ;
5252 wxIcon *result;
5253 PyObject * obj0 = 0 ;
5254 char *kwnames[] = {
5255 (char *) "loc", NULL
5256 };
5257
5258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5259 {
5260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5261 if (SWIG_arg_fail(1)) SWIG_fail;
5262 if (arg1 == NULL) {
5263 SWIG_null_ref("wxIconLocation");
5264 }
5265 if (SWIG_arg_fail(1)) SWIG_fail;
5266 }
5267 {
5268 if (!wxPyCheckForApp()) SWIG_fail;
5269 PyThreadState* __tstate = wxPyBeginAllowThreads();
5270 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5271
5272 wxPyEndAllowThreads(__tstate);
5273 if (PyErr_Occurred()) SWIG_fail;
5274 }
5275 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5276 return resultobj;
5277 fail:
5278 return NULL;
5279 }
5280
5281
5282 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5283 PyObject *resultobj;
5284 wxBitmap *arg1 = 0 ;
5285 wxIcon *result;
5286 PyObject * obj0 = 0 ;
5287 char *kwnames[] = {
5288 (char *) "bmp", NULL
5289 };
5290
5291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5292 {
5293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5294 if (SWIG_arg_fail(1)) SWIG_fail;
5295 if (arg1 == NULL) {
5296 SWIG_null_ref("wxBitmap");
5297 }
5298 if (SWIG_arg_fail(1)) SWIG_fail;
5299 }
5300 {
5301 if (!wxPyCheckForApp()) SWIG_fail;
5302 PyThreadState* __tstate = wxPyBeginAllowThreads();
5303 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5304
5305 wxPyEndAllowThreads(__tstate);
5306 if (PyErr_Occurred()) SWIG_fail;
5307 }
5308 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5309 return resultobj;
5310 fail:
5311 return NULL;
5312 }
5313
5314
5315 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5316 PyObject *resultobj;
5317 PyObject *arg1 = (PyObject *) 0 ;
5318 wxIcon *result;
5319 PyObject * obj0 = 0 ;
5320 char *kwnames[] = {
5321 (char *) "listOfStrings", NULL
5322 };
5323
5324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5325 arg1 = obj0;
5326 {
5327 if (!wxPyCheckForApp()) SWIG_fail;
5328 PyThreadState* __tstate = wxPyBeginAllowThreads();
5329 result = (wxIcon *)new_wxIcon(arg1);
5330
5331 wxPyEndAllowThreads(__tstate);
5332 if (PyErr_Occurred()) SWIG_fail;
5333 }
5334 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5335 return resultobj;
5336 fail:
5337 return NULL;
5338 }
5339
5340
5341 static PyObject *_wrap_Icon_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
5342 PyObject *resultobj;
5343 wxIcon *arg1 = (wxIcon *) 0 ;
5344 wxString *arg2 = 0 ;
5345 wxBitmapType arg3 ;
5346 bool result;
5347 bool temp2 = false ;
5348 PyObject * obj0 = 0 ;
5349 PyObject * obj1 = 0 ;
5350 PyObject * obj2 = 0 ;
5351 char *kwnames[] = {
5352 (char *) "self",(char *) "name",(char *) "type", NULL
5353 };
5354
5355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Icon_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5357 if (SWIG_arg_fail(1)) SWIG_fail;
5358 {
5359 arg2 = wxString_in_helper(obj1);
5360 if (arg2 == NULL) SWIG_fail;
5361 temp2 = true;
5362 }
5363 {
5364 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
5365 if (SWIG_arg_fail(3)) SWIG_fail;
5366 }
5367 {
5368 PyThreadState* __tstate = wxPyBeginAllowThreads();
5369 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
5370
5371 wxPyEndAllowThreads(__tstate);
5372 if (PyErr_Occurred()) SWIG_fail;
5373 }
5374 {
5375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5376 }
5377 {
5378 if (temp2)
5379 delete arg2;
5380 }
5381 return resultobj;
5382 fail:
5383 {
5384 if (temp2)
5385 delete arg2;
5386 }
5387 return NULL;
5388 }
5389
5390
5391 static PyObject *_wrap_Icon_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
5392 PyObject *resultobj;
5393 wxIcon *arg1 = (wxIcon *) 0 ;
5394 long result;
5395 PyObject * obj0 = 0 ;
5396 char *kwnames[] = {
5397 (char *) "self", NULL
5398 };
5399
5400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHandle",kwnames,&obj0)) goto fail;
5401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5402 if (SWIG_arg_fail(1)) SWIG_fail;
5403 {
5404 PyThreadState* __tstate = wxPyBeginAllowThreads();
5405 result = (long)(arg1)->GetHandle();
5406
5407 wxPyEndAllowThreads(__tstate);
5408 if (PyErr_Occurred()) SWIG_fail;
5409 }
5410 {
5411 resultobj = SWIG_From_long((long)(result));
5412 }
5413 return resultobj;
5414 fail:
5415 return NULL;
5416 }
5417
5418
5419 static PyObject *_wrap_Icon_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
5420 PyObject *resultobj;
5421 wxIcon *arg1 = (wxIcon *) 0 ;
5422 long arg2 ;
5423 PyObject * obj0 = 0 ;
5424 PyObject * obj1 = 0 ;
5425 char *kwnames[] = {
5426 (char *) "self",(char *) "handle", NULL
5427 };
5428
5429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHandle",kwnames,&obj0,&obj1)) goto fail;
5430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5431 if (SWIG_arg_fail(1)) SWIG_fail;
5432 {
5433 arg2 = (long)(SWIG_As_long(obj1));
5434 if (SWIG_arg_fail(2)) SWIG_fail;
5435 }
5436 {
5437 PyThreadState* __tstate = wxPyBeginAllowThreads();
5438 wxIcon_SetHandle(arg1,arg2);
5439
5440 wxPyEndAllowThreads(__tstate);
5441 if (PyErr_Occurred()) SWIG_fail;
5442 }
5443 Py_INCREF(Py_None); resultobj = Py_None;
5444 return resultobj;
5445 fail:
5446 return NULL;
5447 }
5448
5449
5450 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5451 PyObject *resultobj;
5452 wxIcon *arg1 = (wxIcon *) 0 ;
5453 bool result;
5454 PyObject * obj0 = 0 ;
5455 char *kwnames[] = {
5456 (char *) "self", NULL
5457 };
5458
5459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5461 if (SWIG_arg_fail(1)) SWIG_fail;
5462 {
5463 PyThreadState* __tstate = wxPyBeginAllowThreads();
5464 result = (bool)(arg1)->Ok();
5465
5466 wxPyEndAllowThreads(__tstate);
5467 if (PyErr_Occurred()) SWIG_fail;
5468 }
5469 {
5470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5471 }
5472 return resultobj;
5473 fail:
5474 return NULL;
5475 }
5476
5477
5478 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5479 PyObject *resultobj;
5480 wxIcon *arg1 = (wxIcon *) 0 ;
5481 int result;
5482 PyObject * obj0 = 0 ;
5483 char *kwnames[] = {
5484 (char *) "self", NULL
5485 };
5486
5487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5489 if (SWIG_arg_fail(1)) SWIG_fail;
5490 {
5491 PyThreadState* __tstate = wxPyBeginAllowThreads();
5492 result = (int)(arg1)->GetWidth();
5493
5494 wxPyEndAllowThreads(__tstate);
5495 if (PyErr_Occurred()) SWIG_fail;
5496 }
5497 {
5498 resultobj = SWIG_From_int((int)(result));
5499 }
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5507 PyObject *resultobj;
5508 wxIcon *arg1 = (wxIcon *) 0 ;
5509 int result;
5510 PyObject * obj0 = 0 ;
5511 char *kwnames[] = {
5512 (char *) "self", NULL
5513 };
5514
5515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5517 if (SWIG_arg_fail(1)) SWIG_fail;
5518 {
5519 PyThreadState* __tstate = wxPyBeginAllowThreads();
5520 result = (int)(arg1)->GetHeight();
5521
5522 wxPyEndAllowThreads(__tstate);
5523 if (PyErr_Occurred()) SWIG_fail;
5524 }
5525 {
5526 resultobj = SWIG_From_int((int)(result));
5527 }
5528 return resultobj;
5529 fail:
5530 return NULL;
5531 }
5532
5533
5534 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5535 PyObject *resultobj;
5536 wxIcon *arg1 = (wxIcon *) 0 ;
5537 int result;
5538 PyObject * obj0 = 0 ;
5539 char *kwnames[] = {
5540 (char *) "self", NULL
5541 };
5542
5543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5545 if (SWIG_arg_fail(1)) SWIG_fail;
5546 {
5547 PyThreadState* __tstate = wxPyBeginAllowThreads();
5548 result = (int)(arg1)->GetDepth();
5549
5550 wxPyEndAllowThreads(__tstate);
5551 if (PyErr_Occurred()) SWIG_fail;
5552 }
5553 {
5554 resultobj = SWIG_From_int((int)(result));
5555 }
5556 return resultobj;
5557 fail:
5558 return NULL;
5559 }
5560
5561
5562 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5563 PyObject *resultobj;
5564 wxIcon *arg1 = (wxIcon *) 0 ;
5565 int arg2 ;
5566 PyObject * obj0 = 0 ;
5567 PyObject * obj1 = 0 ;
5568 char *kwnames[] = {
5569 (char *) "self",(char *) "w", NULL
5570 };
5571
5572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5574 if (SWIG_arg_fail(1)) SWIG_fail;
5575 {
5576 arg2 = (int)(SWIG_As_int(obj1));
5577 if (SWIG_arg_fail(2)) SWIG_fail;
5578 }
5579 {
5580 PyThreadState* __tstate = wxPyBeginAllowThreads();
5581 (arg1)->SetWidth(arg2);
5582
5583 wxPyEndAllowThreads(__tstate);
5584 if (PyErr_Occurred()) SWIG_fail;
5585 }
5586 Py_INCREF(Py_None); resultobj = Py_None;
5587 return resultobj;
5588 fail:
5589 return NULL;
5590 }
5591
5592
5593 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5594 PyObject *resultobj;
5595 wxIcon *arg1 = (wxIcon *) 0 ;
5596 int arg2 ;
5597 PyObject * obj0 = 0 ;
5598 PyObject * obj1 = 0 ;
5599 char *kwnames[] = {
5600 (char *) "self",(char *) "h", NULL
5601 };
5602
5603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5605 if (SWIG_arg_fail(1)) SWIG_fail;
5606 {
5607 arg2 = (int)(SWIG_As_int(obj1));
5608 if (SWIG_arg_fail(2)) SWIG_fail;
5609 }
5610 {
5611 PyThreadState* __tstate = wxPyBeginAllowThreads();
5612 (arg1)->SetHeight(arg2);
5613
5614 wxPyEndAllowThreads(__tstate);
5615 if (PyErr_Occurred()) SWIG_fail;
5616 }
5617 Py_INCREF(Py_None); resultobj = Py_None;
5618 return resultobj;
5619 fail:
5620 return NULL;
5621 }
5622
5623
5624 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5625 PyObject *resultobj;
5626 wxIcon *arg1 = (wxIcon *) 0 ;
5627 int arg2 ;
5628 PyObject * obj0 = 0 ;
5629 PyObject * obj1 = 0 ;
5630 char *kwnames[] = {
5631 (char *) "self",(char *) "d", NULL
5632 };
5633
5634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5636 if (SWIG_arg_fail(1)) SWIG_fail;
5637 {
5638 arg2 = (int)(SWIG_As_int(obj1));
5639 if (SWIG_arg_fail(2)) SWIG_fail;
5640 }
5641 {
5642 PyThreadState* __tstate = wxPyBeginAllowThreads();
5643 (arg1)->SetDepth(arg2);
5644
5645 wxPyEndAllowThreads(__tstate);
5646 if (PyErr_Occurred()) SWIG_fail;
5647 }
5648 Py_INCREF(Py_None); resultobj = Py_None;
5649 return resultobj;
5650 fail:
5651 return NULL;
5652 }
5653
5654
5655 static PyObject *_wrap_Icon_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5656 PyObject *resultobj;
5657 wxIcon *arg1 = (wxIcon *) 0 ;
5658 wxSize *arg2 = 0 ;
5659 wxSize temp2 ;
5660 PyObject * obj0 = 0 ;
5661 PyObject * obj1 = 0 ;
5662 char *kwnames[] = {
5663 (char *) "self",(char *) "size", NULL
5664 };
5665
5666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetSize",kwnames,&obj0,&obj1)) goto fail;
5667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5668 if (SWIG_arg_fail(1)) SWIG_fail;
5669 {
5670 arg2 = &temp2;
5671 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5672 }
5673 {
5674 PyThreadState* __tstate = wxPyBeginAllowThreads();
5675 (arg1)->SetSize((wxSize const &)*arg2);
5676
5677 wxPyEndAllowThreads(__tstate);
5678 if (PyErr_Occurred()) SWIG_fail;
5679 }
5680 Py_INCREF(Py_None); resultobj = Py_None;
5681 return resultobj;
5682 fail:
5683 return NULL;
5684 }
5685
5686
5687 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5688 PyObject *resultobj;
5689 wxIcon *arg1 = (wxIcon *) 0 ;
5690 wxBitmap *arg2 = 0 ;
5691 PyObject * obj0 = 0 ;
5692 PyObject * obj1 = 0 ;
5693 char *kwnames[] = {
5694 (char *) "self",(char *) "bmp", NULL
5695 };
5696
5697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5699 if (SWIG_arg_fail(1)) SWIG_fail;
5700 {
5701 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5702 if (SWIG_arg_fail(2)) SWIG_fail;
5703 if (arg2 == NULL) {
5704 SWIG_null_ref("wxBitmap");
5705 }
5706 if (SWIG_arg_fail(2)) SWIG_fail;
5707 }
5708 {
5709 PyThreadState* __tstate = wxPyBeginAllowThreads();
5710 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5711
5712 wxPyEndAllowThreads(__tstate);
5713 if (PyErr_Occurred()) SWIG_fail;
5714 }
5715 Py_INCREF(Py_None); resultobj = Py_None;
5716 return resultobj;
5717 fail:
5718 return NULL;
5719 }
5720
5721
5722 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5723 PyObject *obj;
5724 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5725 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5726 Py_INCREF(obj);
5727 return Py_BuildValue((char *)"");
5728 }
5729 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5730 PyObject *resultobj;
5731 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5732 int arg2 = (int) 0 ;
5733 wxIconLocation *result;
5734 bool temp1 = false ;
5735 PyObject * obj0 = 0 ;
5736 PyObject * obj1 = 0 ;
5737 char *kwnames[] = {
5738 (char *) "filename",(char *) "num", NULL
5739 };
5740
5741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5742 if (obj0) {
5743 {
5744 arg1 = wxString_in_helper(obj0);
5745 if (arg1 == NULL) SWIG_fail;
5746 temp1 = true;
5747 }
5748 }
5749 if (obj1) {
5750 {
5751 arg2 = (int)(SWIG_As_int(obj1));
5752 if (SWIG_arg_fail(2)) SWIG_fail;
5753 }
5754 }
5755 {
5756 PyThreadState* __tstate = wxPyBeginAllowThreads();
5757 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5758
5759 wxPyEndAllowThreads(__tstate);
5760 if (PyErr_Occurred()) SWIG_fail;
5761 }
5762 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5763 {
5764 if (temp1)
5765 delete arg1;
5766 }
5767 return resultobj;
5768 fail:
5769 {
5770 if (temp1)
5771 delete arg1;
5772 }
5773 return NULL;
5774 }
5775
5776
5777 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5778 PyObject *resultobj;
5779 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5780 PyObject * obj0 = 0 ;
5781 char *kwnames[] = {
5782 (char *) "self", NULL
5783 };
5784
5785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5787 if (SWIG_arg_fail(1)) SWIG_fail;
5788 {
5789 PyThreadState* __tstate = wxPyBeginAllowThreads();
5790 delete arg1;
5791
5792 wxPyEndAllowThreads(__tstate);
5793 if (PyErr_Occurred()) SWIG_fail;
5794 }
5795 Py_INCREF(Py_None); resultobj = Py_None;
5796 return resultobj;
5797 fail:
5798 return NULL;
5799 }
5800
5801
5802 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5803 PyObject *resultobj;
5804 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5805 bool result;
5806 PyObject * obj0 = 0 ;
5807 char *kwnames[] = {
5808 (char *) "self", NULL
5809 };
5810
5811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5813 if (SWIG_arg_fail(1)) SWIG_fail;
5814 {
5815 PyThreadState* __tstate = wxPyBeginAllowThreads();
5816 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5817
5818 wxPyEndAllowThreads(__tstate);
5819 if (PyErr_Occurred()) SWIG_fail;
5820 }
5821 {
5822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5823 }
5824 return resultobj;
5825 fail:
5826 return NULL;
5827 }
5828
5829
5830 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5831 PyObject *resultobj;
5832 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5833 wxString *arg2 = 0 ;
5834 bool temp2 = false ;
5835 PyObject * obj0 = 0 ;
5836 PyObject * obj1 = 0 ;
5837 char *kwnames[] = {
5838 (char *) "self",(char *) "filename", NULL
5839 };
5840
5841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5843 if (SWIG_arg_fail(1)) SWIG_fail;
5844 {
5845 arg2 = wxString_in_helper(obj1);
5846 if (arg2 == NULL) SWIG_fail;
5847 temp2 = true;
5848 }
5849 {
5850 PyThreadState* __tstate = wxPyBeginAllowThreads();
5851 (arg1)->SetFileName((wxString const &)*arg2);
5852
5853 wxPyEndAllowThreads(__tstate);
5854 if (PyErr_Occurred()) SWIG_fail;
5855 }
5856 Py_INCREF(Py_None); resultobj = Py_None;
5857 {
5858 if (temp2)
5859 delete arg2;
5860 }
5861 return resultobj;
5862 fail:
5863 {
5864 if (temp2)
5865 delete arg2;
5866 }
5867 return NULL;
5868 }
5869
5870
5871 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5872 PyObject *resultobj;
5873 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5874 wxString *result;
5875 PyObject * obj0 = 0 ;
5876 char *kwnames[] = {
5877 (char *) "self", NULL
5878 };
5879
5880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5882 if (SWIG_arg_fail(1)) SWIG_fail;
5883 {
5884 PyThreadState* __tstate = wxPyBeginAllowThreads();
5885 {
5886 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5887 result = (wxString *) &_result_ref;
5888 }
5889
5890 wxPyEndAllowThreads(__tstate);
5891 if (PyErr_Occurred()) SWIG_fail;
5892 }
5893 {
5894 #if wxUSE_UNICODE
5895 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5896 #else
5897 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5898 #endif
5899 }
5900 return resultobj;
5901 fail:
5902 return NULL;
5903 }
5904
5905
5906 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5907 PyObject *resultobj;
5908 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5909 int arg2 ;
5910 PyObject * obj0 = 0 ;
5911 PyObject * obj1 = 0 ;
5912 char *kwnames[] = {
5913 (char *) "self",(char *) "num", NULL
5914 };
5915
5916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5918 if (SWIG_arg_fail(1)) SWIG_fail;
5919 {
5920 arg2 = (int)(SWIG_As_int(obj1));
5921 if (SWIG_arg_fail(2)) SWIG_fail;
5922 }
5923 {
5924 PyThreadState* __tstate = wxPyBeginAllowThreads();
5925 wxIconLocation_SetIndex(arg1,arg2);
5926
5927 wxPyEndAllowThreads(__tstate);
5928 if (PyErr_Occurred()) SWIG_fail;
5929 }
5930 Py_INCREF(Py_None); resultobj = Py_None;
5931 return resultobj;
5932 fail:
5933 return NULL;
5934 }
5935
5936
5937 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5938 PyObject *resultobj;
5939 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5940 int result;
5941 PyObject * obj0 = 0 ;
5942 char *kwnames[] = {
5943 (char *) "self", NULL
5944 };
5945
5946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5948 if (SWIG_arg_fail(1)) SWIG_fail;
5949 {
5950 PyThreadState* __tstate = wxPyBeginAllowThreads();
5951 result = (int)wxIconLocation_GetIndex(arg1);
5952
5953 wxPyEndAllowThreads(__tstate);
5954 if (PyErr_Occurred()) SWIG_fail;
5955 }
5956 {
5957 resultobj = SWIG_From_int((int)(result));
5958 }
5959 return resultobj;
5960 fail:
5961 return NULL;
5962 }
5963
5964
5965 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5966 PyObject *obj;
5967 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5968 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5969 Py_INCREF(obj);
5970 return Py_BuildValue((char *)"");
5971 }
5972 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5973 PyObject *resultobj;
5974 wxIconBundle *result;
5975 char *kwnames[] = {
5976 NULL
5977 };
5978
5979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5980 {
5981 PyThreadState* __tstate = wxPyBeginAllowThreads();
5982 result = (wxIconBundle *)new wxIconBundle();
5983
5984 wxPyEndAllowThreads(__tstate);
5985 if (PyErr_Occurred()) SWIG_fail;
5986 }
5987 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5988 return resultobj;
5989 fail:
5990 return NULL;
5991 }
5992
5993
5994 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5995 PyObject *resultobj;
5996 wxString *arg1 = 0 ;
5997 long arg2 ;
5998 wxIconBundle *result;
5999 bool temp1 = false ;
6000 PyObject * obj0 = 0 ;
6001 PyObject * obj1 = 0 ;
6002 char *kwnames[] = {
6003 (char *) "file",(char *) "type", NULL
6004 };
6005
6006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
6007 {
6008 arg1 = wxString_in_helper(obj0);
6009 if (arg1 == NULL) SWIG_fail;
6010 temp1 = true;
6011 }
6012 {
6013 arg2 = (long)(SWIG_As_long(obj1));
6014 if (SWIG_arg_fail(2)) SWIG_fail;
6015 }
6016 {
6017 PyThreadState* __tstate = wxPyBeginAllowThreads();
6018 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
6019
6020 wxPyEndAllowThreads(__tstate);
6021 if (PyErr_Occurred()) SWIG_fail;
6022 }
6023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
6024 {
6025 if (temp1)
6026 delete arg1;
6027 }
6028 return resultobj;
6029 fail:
6030 {
6031 if (temp1)
6032 delete arg1;
6033 }
6034 return NULL;
6035 }
6036
6037
6038 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6039 PyObject *resultobj;
6040 wxIcon *arg1 = 0 ;
6041 wxIconBundle *result;
6042 PyObject * obj0 = 0 ;
6043 char *kwnames[] = {
6044 (char *) "icon", NULL
6045 };
6046
6047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
6048 {
6049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
6050 if (SWIG_arg_fail(1)) SWIG_fail;
6051 if (arg1 == NULL) {
6052 SWIG_null_ref("wxIcon");
6053 }
6054 if (SWIG_arg_fail(1)) SWIG_fail;
6055 }
6056 {
6057 PyThreadState* __tstate = wxPyBeginAllowThreads();
6058 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
6059
6060 wxPyEndAllowThreads(__tstate);
6061 if (PyErr_Occurred()) SWIG_fail;
6062 }
6063 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
6064 return resultobj;
6065 fail:
6066 return NULL;
6067 }
6068
6069
6070 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
6071 PyObject *resultobj;
6072 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6073 PyObject * obj0 = 0 ;
6074 char *kwnames[] = {
6075 (char *) "self", NULL
6076 };
6077
6078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
6079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6080 if (SWIG_arg_fail(1)) SWIG_fail;
6081 {
6082 PyThreadState* __tstate = wxPyBeginAllowThreads();
6083 delete arg1;
6084
6085 wxPyEndAllowThreads(__tstate);
6086 if (PyErr_Occurred()) SWIG_fail;
6087 }
6088 Py_INCREF(Py_None); resultobj = Py_None;
6089 return resultobj;
6090 fail:
6091 return NULL;
6092 }
6093
6094
6095 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6096 PyObject *resultobj;
6097 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6098 wxIcon *arg2 = 0 ;
6099 PyObject * obj0 = 0 ;
6100 PyObject * obj1 = 0 ;
6101 char *kwnames[] = {
6102 (char *) "self",(char *) "icon", NULL
6103 };
6104
6105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
6106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6107 if (SWIG_arg_fail(1)) SWIG_fail;
6108 {
6109 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
6110 if (SWIG_arg_fail(2)) SWIG_fail;
6111 if (arg2 == NULL) {
6112 SWIG_null_ref("wxIcon");
6113 }
6114 if (SWIG_arg_fail(2)) SWIG_fail;
6115 }
6116 {
6117 PyThreadState* __tstate = wxPyBeginAllowThreads();
6118 (arg1)->AddIcon((wxIcon const &)*arg2);
6119
6120 wxPyEndAllowThreads(__tstate);
6121 if (PyErr_Occurred()) SWIG_fail;
6122 }
6123 Py_INCREF(Py_None); resultobj = Py_None;
6124 return resultobj;
6125 fail:
6126 return NULL;
6127 }
6128
6129
6130 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
6131 PyObject *resultobj;
6132 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6133 wxString *arg2 = 0 ;
6134 long arg3 ;
6135 bool temp2 = false ;
6136 PyObject * obj0 = 0 ;
6137 PyObject * obj1 = 0 ;
6138 PyObject * obj2 = 0 ;
6139 char *kwnames[] = {
6140 (char *) "self",(char *) "file",(char *) "type", NULL
6141 };
6142
6143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
6144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6145 if (SWIG_arg_fail(1)) SWIG_fail;
6146 {
6147 arg2 = wxString_in_helper(obj1);
6148 if (arg2 == NULL) SWIG_fail;
6149 temp2 = true;
6150 }
6151 {
6152 arg3 = (long)(SWIG_As_long(obj2));
6153 if (SWIG_arg_fail(3)) SWIG_fail;
6154 }
6155 {
6156 PyThreadState* __tstate = wxPyBeginAllowThreads();
6157 (arg1)->AddIcon((wxString const &)*arg2,arg3);
6158
6159 wxPyEndAllowThreads(__tstate);
6160 if (PyErr_Occurred()) SWIG_fail;
6161 }
6162 Py_INCREF(Py_None); resultobj = Py_None;
6163 {
6164 if (temp2)
6165 delete arg2;
6166 }
6167 return resultobj;
6168 fail:
6169 {
6170 if (temp2)
6171 delete arg2;
6172 }
6173 return NULL;
6174 }
6175
6176
6177 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6178 PyObject *resultobj;
6179 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6180 wxSize *arg2 = 0 ;
6181 wxIcon *result;
6182 wxSize temp2 ;
6183 PyObject * obj0 = 0 ;
6184 PyObject * obj1 = 0 ;
6185 char *kwnames[] = {
6186 (char *) "self",(char *) "size", NULL
6187 };
6188
6189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
6190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6191 if (SWIG_arg_fail(1)) SWIG_fail;
6192 {
6193 arg2 = &temp2;
6194 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6195 }
6196 {
6197 PyThreadState* __tstate = wxPyBeginAllowThreads();
6198 {
6199 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
6200 result = (wxIcon *) &_result_ref;
6201 }
6202
6203 wxPyEndAllowThreads(__tstate);
6204 if (PyErr_Occurred()) SWIG_fail;
6205 }
6206 {
6207 wxIcon* resultptr = new wxIcon(*result);
6208 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
6209 }
6210 return resultobj;
6211 fail:
6212 return NULL;
6213 }
6214
6215
6216 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
6217 PyObject *obj;
6218 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6219 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
6220 Py_INCREF(obj);
6221 return Py_BuildValue((char *)"");
6222 }
6223 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6224 PyObject *resultobj;
6225 wxString *arg1 = (wxString *) 0 ;
6226 long arg2 ;
6227 int arg3 = (int) 0 ;
6228 int arg4 = (int) 0 ;
6229 wxCursor *result;
6230 bool temp1 = false ;
6231 PyObject * obj0 = 0 ;
6232 PyObject * obj1 = 0 ;
6233 PyObject * obj2 = 0 ;
6234 PyObject * obj3 = 0 ;
6235 char *kwnames[] = {
6236 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
6237 };
6238
6239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6240 {
6241 arg1 = wxString_in_helper(obj0);
6242 if (arg1 == NULL) SWIG_fail;
6243 temp1 = true;
6244 }
6245 {
6246 arg2 = (long)(SWIG_As_long(obj1));
6247 if (SWIG_arg_fail(2)) SWIG_fail;
6248 }
6249 if (obj2) {
6250 {
6251 arg3 = (int)(SWIG_As_int(obj2));
6252 if (SWIG_arg_fail(3)) SWIG_fail;
6253 }
6254 }
6255 if (obj3) {
6256 {
6257 arg4 = (int)(SWIG_As_int(obj3));
6258 if (SWIG_arg_fail(4)) SWIG_fail;
6259 }
6260 }
6261 {
6262 if (!wxPyCheckForApp()) SWIG_fail;
6263 PyThreadState* __tstate = wxPyBeginAllowThreads();
6264 result = (wxCursor *)new_wxCursor((wxString const *)arg1,arg2,arg3,arg4);
6265
6266 wxPyEndAllowThreads(__tstate);
6267 if (PyErr_Occurred()) SWIG_fail;
6268 }
6269 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6270 {
6271 if (temp1)
6272 delete arg1;
6273 }
6274 return resultobj;
6275 fail:
6276 {
6277 if (temp1)
6278 delete arg1;
6279 }
6280 return NULL;
6281 }
6282
6283
6284 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6285 PyObject *resultobj;
6286 wxCursor *arg1 = (wxCursor *) 0 ;
6287 PyObject * obj0 = 0 ;
6288 char *kwnames[] = {
6289 (char *) "self", NULL
6290 };
6291
6292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
6293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6294 if (SWIG_arg_fail(1)) SWIG_fail;
6295 {
6296 PyThreadState* __tstate = wxPyBeginAllowThreads();
6297 delete arg1;
6298
6299 wxPyEndAllowThreads(__tstate);
6300 if (PyErr_Occurred()) SWIG_fail;
6301 }
6302 Py_INCREF(Py_None); resultobj = Py_None;
6303 return resultobj;
6304 fail:
6305 return NULL;
6306 }
6307
6308
6309 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6310 PyObject *resultobj;
6311 int arg1 ;
6312 wxCursor *result;
6313 PyObject * obj0 = 0 ;
6314 char *kwnames[] = {
6315 (char *) "id", NULL
6316 };
6317
6318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
6319 {
6320 arg1 = (int)(SWIG_As_int(obj0));
6321 if (SWIG_arg_fail(1)) SWIG_fail;
6322 }
6323 {
6324 if (!wxPyCheckForApp()) SWIG_fail;
6325 PyThreadState* __tstate = wxPyBeginAllowThreads();
6326 result = (wxCursor *)new wxCursor(arg1);
6327
6328 wxPyEndAllowThreads(__tstate);
6329 if (PyErr_Occurred()) SWIG_fail;
6330 }
6331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6332 return resultobj;
6333 fail:
6334 return NULL;
6335 }
6336
6337
6338 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6339 PyObject *resultobj;
6340 wxImage *arg1 = 0 ;
6341 wxCursor *result;
6342 PyObject * obj0 = 0 ;
6343 char *kwnames[] = {
6344 (char *) "image", NULL
6345 };
6346
6347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6348 {
6349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6350 if (SWIG_arg_fail(1)) SWIG_fail;
6351 if (arg1 == NULL) {
6352 SWIG_null_ref("wxImage");
6353 }
6354 if (SWIG_arg_fail(1)) SWIG_fail;
6355 }
6356 {
6357 if (!wxPyCheckForApp()) SWIG_fail;
6358 PyThreadState* __tstate = wxPyBeginAllowThreads();
6359 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6360
6361 wxPyEndAllowThreads(__tstate);
6362 if (PyErr_Occurred()) SWIG_fail;
6363 }
6364 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6365 return resultobj;
6366 fail:
6367 return NULL;
6368 }
6369
6370
6371 static PyObject *_wrap_Cursor_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
6372 PyObject *resultobj;
6373 wxCursor *arg1 = (wxCursor *) 0 ;
6374 long result;
6375 PyObject * obj0 = 0 ;
6376 char *kwnames[] = {
6377 (char *) "self", NULL
6378 };
6379
6380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetHandle",kwnames,&obj0)) goto fail;
6381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6382 if (SWIG_arg_fail(1)) SWIG_fail;
6383 {
6384 PyThreadState* __tstate = wxPyBeginAllowThreads();
6385 result = (long)(arg1)->GetHandle();
6386
6387 wxPyEndAllowThreads(__tstate);
6388 if (PyErr_Occurred()) SWIG_fail;
6389 }
6390 {
6391 resultobj = SWIG_From_long((long)(result));
6392 }
6393 return resultobj;
6394 fail:
6395 return NULL;
6396 }
6397
6398
6399 static PyObject *_wrap_Cursor_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
6400 PyObject *resultobj;
6401 wxCursor *arg1 = (wxCursor *) 0 ;
6402 long arg2 ;
6403 PyObject * obj0 = 0 ;
6404 PyObject * obj1 = 0 ;
6405 char *kwnames[] = {
6406 (char *) "self",(char *) "handle", NULL
6407 };
6408
6409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetHandle",kwnames,&obj0,&obj1)) goto fail;
6410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6411 if (SWIG_arg_fail(1)) SWIG_fail;
6412 {
6413 arg2 = (long)(SWIG_As_long(obj1));
6414 if (SWIG_arg_fail(2)) SWIG_fail;
6415 }
6416 {
6417 PyThreadState* __tstate = wxPyBeginAllowThreads();
6418 wxCursor_SetHandle(arg1,arg2);
6419
6420 wxPyEndAllowThreads(__tstate);
6421 if (PyErr_Occurred()) SWIG_fail;
6422 }
6423 Py_INCREF(Py_None); resultobj = Py_None;
6424 return resultobj;
6425 fail:
6426 return NULL;
6427 }
6428
6429
6430 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6431 PyObject *resultobj;
6432 wxCursor *arg1 = (wxCursor *) 0 ;
6433 bool result;
6434 PyObject * obj0 = 0 ;
6435 char *kwnames[] = {
6436 (char *) "self", NULL
6437 };
6438
6439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6441 if (SWIG_arg_fail(1)) SWIG_fail;
6442 {
6443 PyThreadState* __tstate = wxPyBeginAllowThreads();
6444 result = (bool)(arg1)->Ok();
6445
6446 wxPyEndAllowThreads(__tstate);
6447 if (PyErr_Occurred()) SWIG_fail;
6448 }
6449 {
6450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6451 }
6452 return resultobj;
6453 fail:
6454 return NULL;
6455 }
6456
6457
6458 static PyObject *_wrap_Cursor_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
6459 PyObject *resultobj;
6460 wxCursor *arg1 = (wxCursor *) 0 ;
6461 int result;
6462 PyObject * obj0 = 0 ;
6463 char *kwnames[] = {
6464 (char *) "self", NULL
6465 };
6466
6467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetWidth",kwnames,&obj0)) goto fail;
6468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6469 if (SWIG_arg_fail(1)) SWIG_fail;
6470 {
6471 PyThreadState* __tstate = wxPyBeginAllowThreads();
6472 result = (int)(arg1)->GetWidth();
6473
6474 wxPyEndAllowThreads(__tstate);
6475 if (PyErr_Occurred()) SWIG_fail;
6476 }
6477 {
6478 resultobj = SWIG_From_int((int)(result));
6479 }
6480 return resultobj;
6481 fail:
6482 return NULL;
6483 }
6484
6485
6486 static PyObject *_wrap_Cursor_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
6487 PyObject *resultobj;
6488 wxCursor *arg1 = (wxCursor *) 0 ;
6489 int result;
6490 PyObject * obj0 = 0 ;
6491 char *kwnames[] = {
6492 (char *) "self", NULL
6493 };
6494
6495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetHeight",kwnames,&obj0)) goto fail;
6496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6497 if (SWIG_arg_fail(1)) SWIG_fail;
6498 {
6499 PyThreadState* __tstate = wxPyBeginAllowThreads();
6500 result = (int)(arg1)->GetHeight();
6501
6502 wxPyEndAllowThreads(__tstate);
6503 if (PyErr_Occurred()) SWIG_fail;
6504 }
6505 {
6506 resultobj = SWIG_From_int((int)(result));
6507 }
6508 return resultobj;
6509 fail:
6510 return NULL;
6511 }
6512
6513
6514 static PyObject *_wrap_Cursor_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
6515 PyObject *resultobj;
6516 wxCursor *arg1 = (wxCursor *) 0 ;
6517 int result;
6518 PyObject * obj0 = 0 ;
6519 char *kwnames[] = {
6520 (char *) "self", NULL
6521 };
6522
6523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetDepth",kwnames,&obj0)) goto fail;
6524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6525 if (SWIG_arg_fail(1)) SWIG_fail;
6526 {
6527 PyThreadState* __tstate = wxPyBeginAllowThreads();
6528 result = (int)(arg1)->GetDepth();
6529
6530 wxPyEndAllowThreads(__tstate);
6531 if (PyErr_Occurred()) SWIG_fail;
6532 }
6533 {
6534 resultobj = SWIG_From_int((int)(result));
6535 }
6536 return resultobj;
6537 fail:
6538 return NULL;
6539 }
6540
6541
6542 static PyObject *_wrap_Cursor_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
6543 PyObject *resultobj;
6544 wxCursor *arg1 = (wxCursor *) 0 ;
6545 int arg2 ;
6546 PyObject * obj0 = 0 ;
6547 PyObject * obj1 = 0 ;
6548 char *kwnames[] = {
6549 (char *) "self",(char *) "w", NULL
6550 };
6551
6552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetWidth",kwnames,&obj0,&obj1)) goto fail;
6553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6554 if (SWIG_arg_fail(1)) SWIG_fail;
6555 {
6556 arg2 = (int)(SWIG_As_int(obj1));
6557 if (SWIG_arg_fail(2)) SWIG_fail;
6558 }
6559 {
6560 PyThreadState* __tstate = wxPyBeginAllowThreads();
6561 (arg1)->SetWidth(arg2);
6562
6563 wxPyEndAllowThreads(__tstate);
6564 if (PyErr_Occurred()) SWIG_fail;
6565 }
6566 Py_INCREF(Py_None); resultobj = Py_None;
6567 return resultobj;
6568 fail:
6569 return NULL;
6570 }
6571
6572
6573 static PyObject *_wrap_Cursor_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
6574 PyObject *resultobj;
6575 wxCursor *arg1 = (wxCursor *) 0 ;
6576 int arg2 ;
6577 PyObject * obj0 = 0 ;
6578 PyObject * obj1 = 0 ;
6579 char *kwnames[] = {
6580 (char *) "self",(char *) "h", NULL
6581 };
6582
6583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetHeight",kwnames,&obj0,&obj1)) goto fail;
6584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6585 if (SWIG_arg_fail(1)) SWIG_fail;
6586 {
6587 arg2 = (int)(SWIG_As_int(obj1));
6588 if (SWIG_arg_fail(2)) SWIG_fail;
6589 }
6590 {
6591 PyThreadState* __tstate = wxPyBeginAllowThreads();
6592 (arg1)->SetHeight(arg2);
6593
6594 wxPyEndAllowThreads(__tstate);
6595 if (PyErr_Occurred()) SWIG_fail;
6596 }
6597 Py_INCREF(Py_None); resultobj = Py_None;
6598 return resultobj;
6599 fail:
6600 return NULL;
6601 }
6602
6603
6604 static PyObject *_wrap_Cursor_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
6605 PyObject *resultobj;
6606 wxCursor *arg1 = (wxCursor *) 0 ;
6607 int arg2 ;
6608 PyObject * obj0 = 0 ;
6609 PyObject * obj1 = 0 ;
6610 char *kwnames[] = {
6611 (char *) "self",(char *) "d", NULL
6612 };
6613
6614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetDepth",kwnames,&obj0,&obj1)) goto fail;
6615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6616 if (SWIG_arg_fail(1)) SWIG_fail;
6617 {
6618 arg2 = (int)(SWIG_As_int(obj1));
6619 if (SWIG_arg_fail(2)) SWIG_fail;
6620 }
6621 {
6622 PyThreadState* __tstate = wxPyBeginAllowThreads();
6623 (arg1)->SetDepth(arg2);
6624
6625 wxPyEndAllowThreads(__tstate);
6626 if (PyErr_Occurred()) SWIG_fail;
6627 }
6628 Py_INCREF(Py_None); resultobj = Py_None;
6629 return resultobj;
6630 fail:
6631 return NULL;
6632 }
6633
6634
6635 static PyObject *_wrap_Cursor_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6636 PyObject *resultobj;
6637 wxCursor *arg1 = (wxCursor *) 0 ;
6638 wxSize *arg2 = 0 ;
6639 wxSize temp2 ;
6640 PyObject * obj0 = 0 ;
6641 PyObject * obj1 = 0 ;
6642 char *kwnames[] = {
6643 (char *) "self",(char *) "size", NULL
6644 };
6645
6646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetSize",kwnames,&obj0,&obj1)) goto fail;
6647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6648 if (SWIG_arg_fail(1)) SWIG_fail;
6649 {
6650 arg2 = &temp2;
6651 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6652 }
6653 {
6654 PyThreadState* __tstate = wxPyBeginAllowThreads();
6655 (arg1)->SetSize((wxSize const &)*arg2);
6656
6657 wxPyEndAllowThreads(__tstate);
6658 if (PyErr_Occurred()) SWIG_fail;
6659 }
6660 Py_INCREF(Py_None); resultobj = Py_None;
6661 return resultobj;
6662 fail:
6663 return NULL;
6664 }
6665
6666
6667 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6668 PyObject *obj;
6669 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6670 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6671 Py_INCREF(obj);
6672 return Py_BuildValue((char *)"");
6673 }
6674 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6675 PyObject *resultobj;
6676 int arg1 = (int) 0 ;
6677 int arg2 = (int) 0 ;
6678 int arg3 = (int) 0 ;
6679 int arg4 = (int) 0 ;
6680 wxRegion *result;
6681 PyObject * obj0 = 0 ;
6682 PyObject * obj1 = 0 ;
6683 PyObject * obj2 = 0 ;
6684 PyObject * obj3 = 0 ;
6685 char *kwnames[] = {
6686 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6687 };
6688
6689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6690 if (obj0) {
6691 {
6692 arg1 = (int)(SWIG_As_int(obj0));
6693 if (SWIG_arg_fail(1)) SWIG_fail;
6694 }
6695 }
6696 if (obj1) {
6697 {
6698 arg2 = (int)(SWIG_As_int(obj1));
6699 if (SWIG_arg_fail(2)) SWIG_fail;
6700 }
6701 }
6702 if (obj2) {
6703 {
6704 arg3 = (int)(SWIG_As_int(obj2));
6705 if (SWIG_arg_fail(3)) SWIG_fail;
6706 }
6707 }
6708 if (obj3) {
6709 {
6710 arg4 = (int)(SWIG_As_int(obj3));
6711 if (SWIG_arg_fail(4)) SWIG_fail;
6712 }
6713 }
6714 {
6715 if (!wxPyCheckForApp()) SWIG_fail;
6716 PyThreadState* __tstate = wxPyBeginAllowThreads();
6717 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6718
6719 wxPyEndAllowThreads(__tstate);
6720 if (PyErr_Occurred()) SWIG_fail;
6721 }
6722 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6723 return resultobj;
6724 fail:
6725 return NULL;
6726 }
6727
6728
6729 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6730 PyObject *resultobj;
6731 wxBitmap *arg1 = 0 ;
6732 wxRegion *result;
6733 PyObject * obj0 = 0 ;
6734 char *kwnames[] = {
6735 (char *) "bmp", NULL
6736 };
6737
6738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6739 {
6740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6741 if (SWIG_arg_fail(1)) SWIG_fail;
6742 if (arg1 == NULL) {
6743 SWIG_null_ref("wxBitmap");
6744 }
6745 if (SWIG_arg_fail(1)) SWIG_fail;
6746 }
6747 {
6748 if (!wxPyCheckForApp()) SWIG_fail;
6749 PyThreadState* __tstate = wxPyBeginAllowThreads();
6750 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6751
6752 wxPyEndAllowThreads(__tstate);
6753 if (PyErr_Occurred()) SWIG_fail;
6754 }
6755 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6756 return resultobj;
6757 fail:
6758 return NULL;
6759 }
6760
6761
6762 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6763 PyObject *resultobj;
6764 wxBitmap *arg1 = 0 ;
6765 wxColour *arg2 = 0 ;
6766 int arg3 = (int) 0 ;
6767 wxRegion *result;
6768 wxColour temp2 ;
6769 PyObject * obj0 = 0 ;
6770 PyObject * obj1 = 0 ;
6771 PyObject * obj2 = 0 ;
6772 char *kwnames[] = {
6773 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6774 };
6775
6776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6777 {
6778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6779 if (SWIG_arg_fail(1)) SWIG_fail;
6780 if (arg1 == NULL) {
6781 SWIG_null_ref("wxBitmap");
6782 }
6783 if (SWIG_arg_fail(1)) SWIG_fail;
6784 }
6785 {
6786 arg2 = &temp2;
6787 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6788 }
6789 if (obj2) {
6790 {
6791 arg3 = (int)(SWIG_As_int(obj2));
6792 if (SWIG_arg_fail(3)) SWIG_fail;
6793 }
6794 }
6795 {
6796 if (!wxPyCheckForApp()) SWIG_fail;
6797 PyThreadState* __tstate = wxPyBeginAllowThreads();
6798 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6799
6800 wxPyEndAllowThreads(__tstate);
6801 if (PyErr_Occurred()) SWIG_fail;
6802 }
6803 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6804 return resultobj;
6805 fail:
6806 return NULL;
6807 }
6808
6809
6810 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6811 PyObject *resultobj;
6812 int arg1 ;
6813 wxPoint *arg2 = (wxPoint *) 0 ;
6814 int arg3 = (int) wxWINDING_RULE ;
6815 wxRegion *result;
6816 PyObject * obj0 = 0 ;
6817 PyObject * obj1 = 0 ;
6818 char *kwnames[] = {
6819 (char *) "points",(char *) "fillStyle", NULL
6820 };
6821
6822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6823 {
6824 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6825 if (arg2 == NULL) SWIG_fail;
6826 }
6827 if (obj1) {
6828 {
6829 arg3 = (int)(SWIG_As_int(obj1));
6830 if (SWIG_arg_fail(3)) SWIG_fail;
6831 }
6832 }
6833 {
6834 if (!wxPyCheckForApp()) SWIG_fail;
6835 PyThreadState* __tstate = wxPyBeginAllowThreads();
6836 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6837
6838 wxPyEndAllowThreads(__tstate);
6839 if (PyErr_Occurred()) SWIG_fail;
6840 }
6841 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6842 {
6843 if (arg2) delete [] arg2;
6844 }
6845 return resultobj;
6846 fail:
6847 {
6848 if (arg2) delete [] arg2;
6849 }
6850 return NULL;
6851 }
6852
6853
6854 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6855 PyObject *resultobj;
6856 wxRegion *arg1 = (wxRegion *) 0 ;
6857 PyObject * obj0 = 0 ;
6858 char *kwnames[] = {
6859 (char *) "self", NULL
6860 };
6861
6862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6864 if (SWIG_arg_fail(1)) SWIG_fail;
6865 {
6866 PyThreadState* __tstate = wxPyBeginAllowThreads();
6867 delete arg1;
6868
6869 wxPyEndAllowThreads(__tstate);
6870 if (PyErr_Occurred()) SWIG_fail;
6871 }
6872 Py_INCREF(Py_None); resultobj = Py_None;
6873 return resultobj;
6874 fail:
6875 return NULL;
6876 }
6877
6878
6879 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6880 PyObject *resultobj;
6881 wxRegion *arg1 = (wxRegion *) 0 ;
6882 PyObject * obj0 = 0 ;
6883 char *kwnames[] = {
6884 (char *) "self", NULL
6885 };
6886
6887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6889 if (SWIG_arg_fail(1)) SWIG_fail;
6890 {
6891 PyThreadState* __tstate = wxPyBeginAllowThreads();
6892 (arg1)->Clear();
6893
6894 wxPyEndAllowThreads(__tstate);
6895 if (PyErr_Occurred()) SWIG_fail;
6896 }
6897 Py_INCREF(Py_None); resultobj = Py_None;
6898 return resultobj;
6899 fail:
6900 return NULL;
6901 }
6902
6903
6904 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6905 PyObject *resultobj;
6906 wxRegion *arg1 = (wxRegion *) 0 ;
6907 int arg2 ;
6908 int arg3 ;
6909 bool result;
6910 PyObject * obj0 = 0 ;
6911 PyObject * obj1 = 0 ;
6912 PyObject * obj2 = 0 ;
6913 char *kwnames[] = {
6914 (char *) "self",(char *) "x",(char *) "y", NULL
6915 };
6916
6917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6919 if (SWIG_arg_fail(1)) SWIG_fail;
6920 {
6921 arg2 = (int)(SWIG_As_int(obj1));
6922 if (SWIG_arg_fail(2)) SWIG_fail;
6923 }
6924 {
6925 arg3 = (int)(SWIG_As_int(obj2));
6926 if (SWIG_arg_fail(3)) SWIG_fail;
6927 }
6928 {
6929 PyThreadState* __tstate = wxPyBeginAllowThreads();
6930 result = (bool)(arg1)->Offset(arg2,arg3);
6931
6932 wxPyEndAllowThreads(__tstate);
6933 if (PyErr_Occurred()) SWIG_fail;
6934 }
6935 {
6936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6937 }
6938 return resultobj;
6939 fail:
6940 return NULL;
6941 }
6942
6943
6944 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6945 PyObject *resultobj;
6946 wxRegion *arg1 = (wxRegion *) 0 ;
6947 int arg2 ;
6948 int arg3 ;
6949 wxRegionContain result;
6950 PyObject * obj0 = 0 ;
6951 PyObject * obj1 = 0 ;
6952 PyObject * obj2 = 0 ;
6953 char *kwnames[] = {
6954 (char *) "self",(char *) "x",(char *) "y", NULL
6955 };
6956
6957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = (int)(SWIG_As_int(obj1));
6962 if (SWIG_arg_fail(2)) SWIG_fail;
6963 }
6964 {
6965 arg3 = (int)(SWIG_As_int(obj2));
6966 if (SWIG_arg_fail(3)) SWIG_fail;
6967 }
6968 {
6969 PyThreadState* __tstate = wxPyBeginAllowThreads();
6970 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6971
6972 wxPyEndAllowThreads(__tstate);
6973 if (PyErr_Occurred()) SWIG_fail;
6974 }
6975 resultobj = SWIG_From_int((result));
6976 return resultobj;
6977 fail:
6978 return NULL;
6979 }
6980
6981
6982 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6983 PyObject *resultobj;
6984 wxRegion *arg1 = (wxRegion *) 0 ;
6985 wxPoint *arg2 = 0 ;
6986 wxRegionContain result;
6987 wxPoint temp2 ;
6988 PyObject * obj0 = 0 ;
6989 PyObject * obj1 = 0 ;
6990 char *kwnames[] = {
6991 (char *) "self",(char *) "pt", NULL
6992 };
6993
6994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6996 if (SWIG_arg_fail(1)) SWIG_fail;
6997 {
6998 arg2 = &temp2;
6999 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7000 }
7001 {
7002 PyThreadState* __tstate = wxPyBeginAllowThreads();
7003 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
7004
7005 wxPyEndAllowThreads(__tstate);
7006 if (PyErr_Occurred()) SWIG_fail;
7007 }
7008 resultobj = SWIG_From_int((result));
7009 return resultobj;
7010 fail:
7011 return NULL;
7012 }
7013
7014
7015 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
7016 PyObject *resultobj;
7017 wxRegion *arg1 = (wxRegion *) 0 ;
7018 wxRect *arg2 = 0 ;
7019 wxRegionContain result;
7020 wxRect temp2 ;
7021 PyObject * obj0 = 0 ;
7022 PyObject * obj1 = 0 ;
7023 char *kwnames[] = {
7024 (char *) "self",(char *) "rect", NULL
7025 };
7026
7027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
7028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7029 if (SWIG_arg_fail(1)) SWIG_fail;
7030 {
7031 arg2 = &temp2;
7032 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7033 }
7034 {
7035 PyThreadState* __tstate = wxPyBeginAllowThreads();
7036 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
7037
7038 wxPyEndAllowThreads(__tstate);
7039 if (PyErr_Occurred()) SWIG_fail;
7040 }
7041 resultobj = SWIG_From_int((result));
7042 return resultobj;
7043 fail:
7044 return NULL;
7045 }
7046
7047
7048 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
7049 PyObject *resultobj;
7050 wxRegion *arg1 = (wxRegion *) 0 ;
7051 int arg2 ;
7052 int arg3 ;
7053 int arg4 ;
7054 int arg5 ;
7055 wxRegionContain result;
7056 PyObject * obj0 = 0 ;
7057 PyObject * obj1 = 0 ;
7058 PyObject * obj2 = 0 ;
7059 PyObject * obj3 = 0 ;
7060 PyObject * obj4 = 0 ;
7061 char *kwnames[] = {
7062 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
7063 };
7064
7065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7067 if (SWIG_arg_fail(1)) SWIG_fail;
7068 {
7069 arg2 = (int)(SWIG_As_int(obj1));
7070 if (SWIG_arg_fail(2)) SWIG_fail;
7071 }
7072 {
7073 arg3 = (int)(SWIG_As_int(obj2));
7074 if (SWIG_arg_fail(3)) SWIG_fail;
7075 }
7076 {
7077 arg4 = (int)(SWIG_As_int(obj3));
7078 if (SWIG_arg_fail(4)) SWIG_fail;
7079 }
7080 {
7081 arg5 = (int)(SWIG_As_int(obj4));
7082 if (SWIG_arg_fail(5)) SWIG_fail;
7083 }
7084 {
7085 PyThreadState* __tstate = wxPyBeginAllowThreads();
7086 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
7087
7088 wxPyEndAllowThreads(__tstate);
7089 if (PyErr_Occurred()) SWIG_fail;
7090 }
7091 resultobj = SWIG_From_int((result));
7092 return resultobj;
7093 fail:
7094 return NULL;
7095 }
7096
7097
7098 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
7099 PyObject *resultobj;
7100 wxRegion *arg1 = (wxRegion *) 0 ;
7101 wxRect result;
7102 PyObject * obj0 = 0 ;
7103 char *kwnames[] = {
7104 (char *) "self", NULL
7105 };
7106
7107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
7108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7109 if (SWIG_arg_fail(1)) SWIG_fail;
7110 {
7111 PyThreadState* __tstate = wxPyBeginAllowThreads();
7112 result = (arg1)->GetBox();
7113
7114 wxPyEndAllowThreads(__tstate);
7115 if (PyErr_Occurred()) SWIG_fail;
7116 }
7117 {
7118 wxRect * resultptr;
7119 resultptr = new wxRect((wxRect &)(result));
7120 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7121 }
7122 return resultobj;
7123 fail:
7124 return NULL;
7125 }
7126
7127
7128 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
7129 PyObject *resultobj;
7130 wxRegion *arg1 = (wxRegion *) 0 ;
7131 int arg2 ;
7132 int arg3 ;
7133 int arg4 ;
7134 int arg5 ;
7135 bool result;
7136 PyObject * obj0 = 0 ;
7137 PyObject * obj1 = 0 ;
7138 PyObject * obj2 = 0 ;
7139 PyObject * obj3 = 0 ;
7140 PyObject * obj4 = 0 ;
7141 char *kwnames[] = {
7142 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7143 };
7144
7145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7147 if (SWIG_arg_fail(1)) SWIG_fail;
7148 {
7149 arg2 = (int)(SWIG_As_int(obj1));
7150 if (SWIG_arg_fail(2)) SWIG_fail;
7151 }
7152 {
7153 arg3 = (int)(SWIG_As_int(obj2));
7154 if (SWIG_arg_fail(3)) SWIG_fail;
7155 }
7156 {
7157 arg4 = (int)(SWIG_As_int(obj3));
7158 if (SWIG_arg_fail(4)) SWIG_fail;
7159 }
7160 {
7161 arg5 = (int)(SWIG_As_int(obj4));
7162 if (SWIG_arg_fail(5)) SWIG_fail;
7163 }
7164 {
7165 PyThreadState* __tstate = wxPyBeginAllowThreads();
7166 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
7167
7168 wxPyEndAllowThreads(__tstate);
7169 if (PyErr_Occurred()) SWIG_fail;
7170 }
7171 {
7172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7173 }
7174 return resultobj;
7175 fail:
7176 return NULL;
7177 }
7178
7179
7180 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
7181 PyObject *resultobj;
7182 wxRegion *arg1 = (wxRegion *) 0 ;
7183 wxRect *arg2 = 0 ;
7184 bool result;
7185 wxRect temp2 ;
7186 PyObject * obj0 = 0 ;
7187 PyObject * obj1 = 0 ;
7188 char *kwnames[] = {
7189 (char *) "self",(char *) "rect", NULL
7190 };
7191
7192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
7193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7194 if (SWIG_arg_fail(1)) SWIG_fail;
7195 {
7196 arg2 = &temp2;
7197 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7198 }
7199 {
7200 PyThreadState* __tstate = wxPyBeginAllowThreads();
7201 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
7202
7203 wxPyEndAllowThreads(__tstate);
7204 if (PyErr_Occurred()) SWIG_fail;
7205 }
7206 {
7207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7208 }
7209 return resultobj;
7210 fail:
7211 return NULL;
7212 }
7213
7214
7215 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7216 PyObject *resultobj;
7217 wxRegion *arg1 = (wxRegion *) 0 ;
7218 wxRegion *arg2 = 0 ;
7219 bool result;
7220 PyObject * obj0 = 0 ;
7221 PyObject * obj1 = 0 ;
7222 char *kwnames[] = {
7223 (char *) "self",(char *) "region", NULL
7224 };
7225
7226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
7227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7228 if (SWIG_arg_fail(1)) SWIG_fail;
7229 {
7230 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7231 if (SWIG_arg_fail(2)) SWIG_fail;
7232 if (arg2 == NULL) {
7233 SWIG_null_ref("wxRegion");
7234 }
7235 if (SWIG_arg_fail(2)) SWIG_fail;
7236 }
7237 {
7238 PyThreadState* __tstate = wxPyBeginAllowThreads();
7239 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
7240
7241 wxPyEndAllowThreads(__tstate);
7242 if (PyErr_Occurred()) SWIG_fail;
7243 }
7244 {
7245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7246 }
7247 return resultobj;
7248 fail:
7249 return NULL;
7250 }
7251
7252
7253 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
7254 PyObject *resultobj;
7255 wxRegion *arg1 = (wxRegion *) 0 ;
7256 bool result;
7257 PyObject * obj0 = 0 ;
7258 char *kwnames[] = {
7259 (char *) "self", NULL
7260 };
7261
7262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
7263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7264 if (SWIG_arg_fail(1)) SWIG_fail;
7265 {
7266 PyThreadState* __tstate = wxPyBeginAllowThreads();
7267 result = (bool)(arg1)->IsEmpty();
7268
7269 wxPyEndAllowThreads(__tstate);
7270 if (PyErr_Occurred()) SWIG_fail;
7271 }
7272 {
7273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7274 }
7275 return resultobj;
7276 fail:
7277 return NULL;
7278 }
7279
7280
7281 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
7282 PyObject *resultobj;
7283 wxRegion *arg1 = (wxRegion *) 0 ;
7284 int arg2 ;
7285 int arg3 ;
7286 int arg4 ;
7287 int arg5 ;
7288 bool result;
7289 PyObject * obj0 = 0 ;
7290 PyObject * obj1 = 0 ;
7291 PyObject * obj2 = 0 ;
7292 PyObject * obj3 = 0 ;
7293 PyObject * obj4 = 0 ;
7294 char *kwnames[] = {
7295 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7296 };
7297
7298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7300 if (SWIG_arg_fail(1)) SWIG_fail;
7301 {
7302 arg2 = (int)(SWIG_As_int(obj1));
7303 if (SWIG_arg_fail(2)) SWIG_fail;
7304 }
7305 {
7306 arg3 = (int)(SWIG_As_int(obj2));
7307 if (SWIG_arg_fail(3)) SWIG_fail;
7308 }
7309 {
7310 arg4 = (int)(SWIG_As_int(obj3));
7311 if (SWIG_arg_fail(4)) SWIG_fail;
7312 }
7313 {
7314 arg5 = (int)(SWIG_As_int(obj4));
7315 if (SWIG_arg_fail(5)) SWIG_fail;
7316 }
7317 {
7318 PyThreadState* __tstate = wxPyBeginAllowThreads();
7319 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
7320
7321 wxPyEndAllowThreads(__tstate);
7322 if (PyErr_Occurred()) SWIG_fail;
7323 }
7324 {
7325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7326 }
7327 return resultobj;
7328 fail:
7329 return NULL;
7330 }
7331
7332
7333 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
7334 PyObject *resultobj;
7335 wxRegion *arg1 = (wxRegion *) 0 ;
7336 wxRect *arg2 = 0 ;
7337 bool result;
7338 wxRect temp2 ;
7339 PyObject * obj0 = 0 ;
7340 PyObject * obj1 = 0 ;
7341 char *kwnames[] = {
7342 (char *) "self",(char *) "rect", NULL
7343 };
7344
7345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
7346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7347 if (SWIG_arg_fail(1)) SWIG_fail;
7348 {
7349 arg2 = &temp2;
7350 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7351 }
7352 {
7353 PyThreadState* __tstate = wxPyBeginAllowThreads();
7354 result = (bool)(arg1)->Union((wxRect const &)*arg2);
7355
7356 wxPyEndAllowThreads(__tstate);
7357 if (PyErr_Occurred()) SWIG_fail;
7358 }
7359 {
7360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7361 }
7362 return resultobj;
7363 fail:
7364 return NULL;
7365 }
7366
7367
7368 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7369 PyObject *resultobj;
7370 wxRegion *arg1 = (wxRegion *) 0 ;
7371 wxRegion *arg2 = 0 ;
7372 bool result;
7373 PyObject * obj0 = 0 ;
7374 PyObject * obj1 = 0 ;
7375 char *kwnames[] = {
7376 (char *) "self",(char *) "region", NULL
7377 };
7378
7379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
7380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7381 if (SWIG_arg_fail(1)) SWIG_fail;
7382 {
7383 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7384 if (SWIG_arg_fail(2)) SWIG_fail;
7385 if (arg2 == NULL) {
7386 SWIG_null_ref("wxRegion");
7387 }
7388 if (SWIG_arg_fail(2)) SWIG_fail;
7389 }
7390 {
7391 PyThreadState* __tstate = wxPyBeginAllowThreads();
7392 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
7393
7394 wxPyEndAllowThreads(__tstate);
7395 if (PyErr_Occurred()) SWIG_fail;
7396 }
7397 {
7398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7399 }
7400 return resultobj;
7401 fail:
7402 return NULL;
7403 }
7404
7405
7406 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
7407 PyObject *resultobj;
7408 wxRegion *arg1 = (wxRegion *) 0 ;
7409 int arg2 ;
7410 int arg3 ;
7411 int arg4 ;
7412 int arg5 ;
7413 bool result;
7414 PyObject * obj0 = 0 ;
7415 PyObject * obj1 = 0 ;
7416 PyObject * obj2 = 0 ;
7417 PyObject * obj3 = 0 ;
7418 PyObject * obj4 = 0 ;
7419 char *kwnames[] = {
7420 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7421 };
7422
7423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7425 if (SWIG_arg_fail(1)) SWIG_fail;
7426 {
7427 arg2 = (int)(SWIG_As_int(obj1));
7428 if (SWIG_arg_fail(2)) SWIG_fail;
7429 }
7430 {
7431 arg3 = (int)(SWIG_As_int(obj2));
7432 if (SWIG_arg_fail(3)) SWIG_fail;
7433 }
7434 {
7435 arg4 = (int)(SWIG_As_int(obj3));
7436 if (SWIG_arg_fail(4)) SWIG_fail;
7437 }
7438 {
7439 arg5 = (int)(SWIG_As_int(obj4));
7440 if (SWIG_arg_fail(5)) SWIG_fail;
7441 }
7442 {
7443 PyThreadState* __tstate = wxPyBeginAllowThreads();
7444 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
7445
7446 wxPyEndAllowThreads(__tstate);
7447 if (PyErr_Occurred()) SWIG_fail;
7448 }
7449 {
7450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7451 }
7452 return resultobj;
7453 fail:
7454 return NULL;
7455 }
7456
7457
7458 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
7459 PyObject *resultobj;
7460 wxRegion *arg1 = (wxRegion *) 0 ;
7461 wxRect *arg2 = 0 ;
7462 bool result;
7463 wxRect temp2 ;
7464 PyObject * obj0 = 0 ;
7465 PyObject * obj1 = 0 ;
7466 char *kwnames[] = {
7467 (char *) "self",(char *) "rect", NULL
7468 };
7469
7470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
7471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7472 if (SWIG_arg_fail(1)) SWIG_fail;
7473 {
7474 arg2 = &temp2;
7475 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7476 }
7477 {
7478 PyThreadState* __tstate = wxPyBeginAllowThreads();
7479 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
7480
7481 wxPyEndAllowThreads(__tstate);
7482 if (PyErr_Occurred()) SWIG_fail;
7483 }
7484 {
7485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7486 }
7487 return resultobj;
7488 fail:
7489 return NULL;
7490 }
7491
7492
7493 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7494 PyObject *resultobj;
7495 wxRegion *arg1 = (wxRegion *) 0 ;
7496 wxRegion *arg2 = 0 ;
7497 bool result;
7498 PyObject * obj0 = 0 ;
7499 PyObject * obj1 = 0 ;
7500 char *kwnames[] = {
7501 (char *) "self",(char *) "region", NULL
7502 };
7503
7504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
7505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7506 if (SWIG_arg_fail(1)) SWIG_fail;
7507 {
7508 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7509 if (SWIG_arg_fail(2)) SWIG_fail;
7510 if (arg2 == NULL) {
7511 SWIG_null_ref("wxRegion");
7512 }
7513 if (SWIG_arg_fail(2)) SWIG_fail;
7514 }
7515 {
7516 PyThreadState* __tstate = wxPyBeginAllowThreads();
7517 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
7518
7519 wxPyEndAllowThreads(__tstate);
7520 if (PyErr_Occurred()) SWIG_fail;
7521 }
7522 {
7523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7524 }
7525 return resultobj;
7526 fail:
7527 return NULL;
7528 }
7529
7530
7531 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
7532 PyObject *resultobj;
7533 wxRegion *arg1 = (wxRegion *) 0 ;
7534 int arg2 ;
7535 int arg3 ;
7536 int arg4 ;
7537 int arg5 ;
7538 bool result;
7539 PyObject * obj0 = 0 ;
7540 PyObject * obj1 = 0 ;
7541 PyObject * obj2 = 0 ;
7542 PyObject * obj3 = 0 ;
7543 PyObject * obj4 = 0 ;
7544 char *kwnames[] = {
7545 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7546 };
7547
7548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7550 if (SWIG_arg_fail(1)) SWIG_fail;
7551 {
7552 arg2 = (int)(SWIG_As_int(obj1));
7553 if (SWIG_arg_fail(2)) SWIG_fail;
7554 }
7555 {
7556 arg3 = (int)(SWIG_As_int(obj2));
7557 if (SWIG_arg_fail(3)) SWIG_fail;
7558 }
7559 {
7560 arg4 = (int)(SWIG_As_int(obj3));
7561 if (SWIG_arg_fail(4)) SWIG_fail;
7562 }
7563 {
7564 arg5 = (int)(SWIG_As_int(obj4));
7565 if (SWIG_arg_fail(5)) SWIG_fail;
7566 }
7567 {
7568 PyThreadState* __tstate = wxPyBeginAllowThreads();
7569 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
7570
7571 wxPyEndAllowThreads(__tstate);
7572 if (PyErr_Occurred()) SWIG_fail;
7573 }
7574 {
7575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7576 }
7577 return resultobj;
7578 fail:
7579 return NULL;
7580 }
7581
7582
7583 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
7584 PyObject *resultobj;
7585 wxRegion *arg1 = (wxRegion *) 0 ;
7586 wxRect *arg2 = 0 ;
7587 bool result;
7588 wxRect temp2 ;
7589 PyObject * obj0 = 0 ;
7590 PyObject * obj1 = 0 ;
7591 char *kwnames[] = {
7592 (char *) "self",(char *) "rect", NULL
7593 };
7594
7595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7597 if (SWIG_arg_fail(1)) SWIG_fail;
7598 {
7599 arg2 = &temp2;
7600 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7601 }
7602 {
7603 PyThreadState* __tstate = wxPyBeginAllowThreads();
7604 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7605
7606 wxPyEndAllowThreads(__tstate);
7607 if (PyErr_Occurred()) SWIG_fail;
7608 }
7609 {
7610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7611 }
7612 return resultobj;
7613 fail:
7614 return NULL;
7615 }
7616
7617
7618 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7619 PyObject *resultobj;
7620 wxRegion *arg1 = (wxRegion *) 0 ;
7621 wxRegion *arg2 = 0 ;
7622 bool result;
7623 PyObject * obj0 = 0 ;
7624 PyObject * obj1 = 0 ;
7625 char *kwnames[] = {
7626 (char *) "self",(char *) "region", NULL
7627 };
7628
7629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7631 if (SWIG_arg_fail(1)) SWIG_fail;
7632 {
7633 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7634 if (SWIG_arg_fail(2)) SWIG_fail;
7635 if (arg2 == NULL) {
7636 SWIG_null_ref("wxRegion");
7637 }
7638 if (SWIG_arg_fail(2)) SWIG_fail;
7639 }
7640 {
7641 PyThreadState* __tstate = wxPyBeginAllowThreads();
7642 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7643
7644 wxPyEndAllowThreads(__tstate);
7645 if (PyErr_Occurred()) SWIG_fail;
7646 }
7647 {
7648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7649 }
7650 return resultobj;
7651 fail:
7652 return NULL;
7653 }
7654
7655
7656 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7657 PyObject *resultobj;
7658 wxRegion *arg1 = (wxRegion *) 0 ;
7659 SwigValueWrapper<wxBitmap > result;
7660 PyObject * obj0 = 0 ;
7661 char *kwnames[] = {
7662 (char *) "self", NULL
7663 };
7664
7665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7667 if (SWIG_arg_fail(1)) SWIG_fail;
7668 {
7669 PyThreadState* __tstate = wxPyBeginAllowThreads();
7670 result = (arg1)->ConvertToBitmap();
7671
7672 wxPyEndAllowThreads(__tstate);
7673 if (PyErr_Occurred()) SWIG_fail;
7674 }
7675 {
7676 wxBitmap * resultptr;
7677 resultptr = new wxBitmap((wxBitmap &)(result));
7678 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7679 }
7680 return resultobj;
7681 fail:
7682 return NULL;
7683 }
7684
7685
7686 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7687 PyObject *resultobj;
7688 wxRegion *arg1 = (wxRegion *) 0 ;
7689 wxBitmap *arg2 = 0 ;
7690 bool result;
7691 PyObject * obj0 = 0 ;
7692 PyObject * obj1 = 0 ;
7693 char *kwnames[] = {
7694 (char *) "self",(char *) "bmp", NULL
7695 };
7696
7697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7699 if (SWIG_arg_fail(1)) SWIG_fail;
7700 {
7701 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7702 if (SWIG_arg_fail(2)) SWIG_fail;
7703 if (arg2 == NULL) {
7704 SWIG_null_ref("wxBitmap");
7705 }
7706 if (SWIG_arg_fail(2)) SWIG_fail;
7707 }
7708 {
7709 PyThreadState* __tstate = wxPyBeginAllowThreads();
7710 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7711
7712 wxPyEndAllowThreads(__tstate);
7713 if (PyErr_Occurred()) SWIG_fail;
7714 }
7715 {
7716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7717 }
7718 return resultobj;
7719 fail:
7720 return NULL;
7721 }
7722
7723
7724 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7725 PyObject *resultobj;
7726 wxRegion *arg1 = (wxRegion *) 0 ;
7727 wxBitmap *arg2 = 0 ;
7728 wxColour *arg3 = 0 ;
7729 int arg4 = (int) 0 ;
7730 bool result;
7731 wxColour temp3 ;
7732 PyObject * obj0 = 0 ;
7733 PyObject * obj1 = 0 ;
7734 PyObject * obj2 = 0 ;
7735 PyObject * obj3 = 0 ;
7736 char *kwnames[] = {
7737 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7738 };
7739
7740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7742 if (SWIG_arg_fail(1)) SWIG_fail;
7743 {
7744 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7745 if (SWIG_arg_fail(2)) SWIG_fail;
7746 if (arg2 == NULL) {
7747 SWIG_null_ref("wxBitmap");
7748 }
7749 if (SWIG_arg_fail(2)) SWIG_fail;
7750 }
7751 {
7752 arg3 = &temp3;
7753 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7754 }
7755 if (obj3) {
7756 {
7757 arg4 = (int)(SWIG_As_int(obj3));
7758 if (SWIG_arg_fail(4)) SWIG_fail;
7759 }
7760 }
7761 {
7762 PyThreadState* __tstate = wxPyBeginAllowThreads();
7763 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7764
7765 wxPyEndAllowThreads(__tstate);
7766 if (PyErr_Occurred()) SWIG_fail;
7767 }
7768 {
7769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7770 }
7771 return resultobj;
7772 fail:
7773 return NULL;
7774 }
7775
7776
7777 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7778 PyObject *obj;
7779 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7780 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7781 Py_INCREF(obj);
7782 return Py_BuildValue((char *)"");
7783 }
7784 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7785 PyObject *resultobj;
7786 wxRegion *arg1 = 0 ;
7787 wxRegionIterator *result;
7788 PyObject * obj0 = 0 ;
7789 char *kwnames[] = {
7790 (char *) "region", NULL
7791 };
7792
7793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7794 {
7795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7796 if (SWIG_arg_fail(1)) SWIG_fail;
7797 if (arg1 == NULL) {
7798 SWIG_null_ref("wxRegion");
7799 }
7800 if (SWIG_arg_fail(1)) SWIG_fail;
7801 }
7802 {
7803 if (!wxPyCheckForApp()) SWIG_fail;
7804 PyThreadState* __tstate = wxPyBeginAllowThreads();
7805 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7806
7807 wxPyEndAllowThreads(__tstate);
7808 if (PyErr_Occurred()) SWIG_fail;
7809 }
7810 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7811 return resultobj;
7812 fail:
7813 return NULL;
7814 }
7815
7816
7817 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7818 PyObject *resultobj;
7819 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7820 PyObject * obj0 = 0 ;
7821 char *kwnames[] = {
7822 (char *) "self", NULL
7823 };
7824
7825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7827 if (SWIG_arg_fail(1)) SWIG_fail;
7828 {
7829 PyThreadState* __tstate = wxPyBeginAllowThreads();
7830 delete arg1;
7831
7832 wxPyEndAllowThreads(__tstate);
7833 if (PyErr_Occurred()) SWIG_fail;
7834 }
7835 Py_INCREF(Py_None); resultobj = Py_None;
7836 return resultobj;
7837 fail:
7838 return NULL;
7839 }
7840
7841
7842 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7843 PyObject *resultobj;
7844 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7845 int result;
7846 PyObject * obj0 = 0 ;
7847 char *kwnames[] = {
7848 (char *) "self", NULL
7849 };
7850
7851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7853 if (SWIG_arg_fail(1)) SWIG_fail;
7854 {
7855 PyThreadState* __tstate = wxPyBeginAllowThreads();
7856 result = (int)(arg1)->GetX();
7857
7858 wxPyEndAllowThreads(__tstate);
7859 if (PyErr_Occurred()) SWIG_fail;
7860 }
7861 {
7862 resultobj = SWIG_From_int((int)(result));
7863 }
7864 return resultobj;
7865 fail:
7866 return NULL;
7867 }
7868
7869
7870 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7871 PyObject *resultobj;
7872 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7873 int result;
7874 PyObject * obj0 = 0 ;
7875 char *kwnames[] = {
7876 (char *) "self", NULL
7877 };
7878
7879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7881 if (SWIG_arg_fail(1)) SWIG_fail;
7882 {
7883 PyThreadState* __tstate = wxPyBeginAllowThreads();
7884 result = (int)(arg1)->GetY();
7885
7886 wxPyEndAllowThreads(__tstate);
7887 if (PyErr_Occurred()) SWIG_fail;
7888 }
7889 {
7890 resultobj = SWIG_From_int((int)(result));
7891 }
7892 return resultobj;
7893 fail:
7894 return NULL;
7895 }
7896
7897
7898 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7899 PyObject *resultobj;
7900 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7901 int result;
7902 PyObject * obj0 = 0 ;
7903 char *kwnames[] = {
7904 (char *) "self", NULL
7905 };
7906
7907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7909 if (SWIG_arg_fail(1)) SWIG_fail;
7910 {
7911 PyThreadState* __tstate = wxPyBeginAllowThreads();
7912 result = (int)(arg1)->GetW();
7913
7914 wxPyEndAllowThreads(__tstate);
7915 if (PyErr_Occurred()) SWIG_fail;
7916 }
7917 {
7918 resultobj = SWIG_From_int((int)(result));
7919 }
7920 return resultobj;
7921 fail:
7922 return NULL;
7923 }
7924
7925
7926 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7927 PyObject *resultobj;
7928 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7929 int result;
7930 PyObject * obj0 = 0 ;
7931 char *kwnames[] = {
7932 (char *) "self", NULL
7933 };
7934
7935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7937 if (SWIG_arg_fail(1)) SWIG_fail;
7938 {
7939 PyThreadState* __tstate = wxPyBeginAllowThreads();
7940 result = (int)(arg1)->GetWidth();
7941
7942 wxPyEndAllowThreads(__tstate);
7943 if (PyErr_Occurred()) SWIG_fail;
7944 }
7945 {
7946 resultobj = SWIG_From_int((int)(result));
7947 }
7948 return resultobj;
7949 fail:
7950 return NULL;
7951 }
7952
7953
7954 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7955 PyObject *resultobj;
7956 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7957 int result;
7958 PyObject * obj0 = 0 ;
7959 char *kwnames[] = {
7960 (char *) "self", NULL
7961 };
7962
7963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7965 if (SWIG_arg_fail(1)) SWIG_fail;
7966 {
7967 PyThreadState* __tstate = wxPyBeginAllowThreads();
7968 result = (int)(arg1)->GetH();
7969
7970 wxPyEndAllowThreads(__tstate);
7971 if (PyErr_Occurred()) SWIG_fail;
7972 }
7973 {
7974 resultobj = SWIG_From_int((int)(result));
7975 }
7976 return resultobj;
7977 fail:
7978 return NULL;
7979 }
7980
7981
7982 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7983 PyObject *resultobj;
7984 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7985 int result;
7986 PyObject * obj0 = 0 ;
7987 char *kwnames[] = {
7988 (char *) "self", NULL
7989 };
7990
7991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7993 if (SWIG_arg_fail(1)) SWIG_fail;
7994 {
7995 PyThreadState* __tstate = wxPyBeginAllowThreads();
7996 result = (int)(arg1)->GetHeight();
7997
7998 wxPyEndAllowThreads(__tstate);
7999 if (PyErr_Occurred()) SWIG_fail;
8000 }
8001 {
8002 resultobj = SWIG_From_int((int)(result));
8003 }
8004 return resultobj;
8005 fail:
8006 return NULL;
8007 }
8008
8009
8010 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
8011 PyObject *resultobj;
8012 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8013 wxRect result;
8014 PyObject * obj0 = 0 ;
8015 char *kwnames[] = {
8016 (char *) "self", NULL
8017 };
8018
8019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
8020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8021 if (SWIG_arg_fail(1)) SWIG_fail;
8022 {
8023 PyThreadState* __tstate = wxPyBeginAllowThreads();
8024 result = (arg1)->GetRect();
8025
8026 wxPyEndAllowThreads(__tstate);
8027 if (PyErr_Occurred()) SWIG_fail;
8028 }
8029 {
8030 wxRect * resultptr;
8031 resultptr = new wxRect((wxRect &)(result));
8032 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
8033 }
8034 return resultobj;
8035 fail:
8036 return NULL;
8037 }
8038
8039
8040 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
8041 PyObject *resultobj;
8042 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8043 bool result;
8044 PyObject * obj0 = 0 ;
8045 char *kwnames[] = {
8046 (char *) "self", NULL
8047 };
8048
8049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
8050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8051 if (SWIG_arg_fail(1)) SWIG_fail;
8052 {
8053 PyThreadState* __tstate = wxPyBeginAllowThreads();
8054 result = (bool)(arg1)->HaveRects();
8055
8056 wxPyEndAllowThreads(__tstate);
8057 if (PyErr_Occurred()) SWIG_fail;
8058 }
8059 {
8060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8061 }
8062 return resultobj;
8063 fail:
8064 return NULL;
8065 }
8066
8067
8068 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
8069 PyObject *resultobj;
8070 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8071 PyObject * obj0 = 0 ;
8072 char *kwnames[] = {
8073 (char *) "self", NULL
8074 };
8075
8076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
8077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8078 if (SWIG_arg_fail(1)) SWIG_fail;
8079 {
8080 PyThreadState* __tstate = wxPyBeginAllowThreads();
8081 (arg1)->Reset();
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_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
8094 PyObject *resultobj;
8095 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8096 PyObject * obj0 = 0 ;
8097 char *kwnames[] = {
8098 (char *) "self", NULL
8099 };
8100
8101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
8102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8103 if (SWIG_arg_fail(1)) SWIG_fail;
8104 {
8105 PyThreadState* __tstate = wxPyBeginAllowThreads();
8106 wxRegionIterator_Next(arg1);
8107
8108 wxPyEndAllowThreads(__tstate);
8109 if (PyErr_Occurred()) SWIG_fail;
8110 }
8111 Py_INCREF(Py_None); resultobj = Py_None;
8112 return resultobj;
8113 fail:
8114 return NULL;
8115 }
8116
8117
8118 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
8119 PyObject *resultobj;
8120 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8121 bool result;
8122 PyObject * obj0 = 0 ;
8123 char *kwnames[] = {
8124 (char *) "self", NULL
8125 };
8126
8127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
8128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8129 if (SWIG_arg_fail(1)) SWIG_fail;
8130 {
8131 PyThreadState* __tstate = wxPyBeginAllowThreads();
8132 result = (bool)wxRegionIterator___nonzero__(arg1);
8133
8134 wxPyEndAllowThreads(__tstate);
8135 if (PyErr_Occurred()) SWIG_fail;
8136 }
8137 {
8138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8139 }
8140 return resultobj;
8141 fail:
8142 return NULL;
8143 }
8144
8145
8146 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
8147 PyObject *obj;
8148 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8149 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
8150 Py_INCREF(obj);
8151 return Py_BuildValue((char *)"");
8152 }
8153 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8154 PyObject *resultobj;
8155 wxNativeFontInfo *result;
8156 char *kwnames[] = {
8157 NULL
8158 };
8159
8160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
8161 {
8162 PyThreadState* __tstate = wxPyBeginAllowThreads();
8163 result = (wxNativeFontInfo *)new wxNativeFontInfo();
8164
8165 wxPyEndAllowThreads(__tstate);
8166 if (PyErr_Occurred()) SWIG_fail;
8167 }
8168 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
8169 return resultobj;
8170 fail:
8171 return NULL;
8172 }
8173
8174
8175 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8176 PyObject *resultobj;
8177 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8178 PyObject * obj0 = 0 ;
8179 char *kwnames[] = {
8180 (char *) "self", NULL
8181 };
8182
8183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
8184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8185 if (SWIG_arg_fail(1)) SWIG_fail;
8186 {
8187 PyThreadState* __tstate = wxPyBeginAllowThreads();
8188 delete arg1;
8189
8190 wxPyEndAllowThreads(__tstate);
8191 if (PyErr_Occurred()) SWIG_fail;
8192 }
8193 Py_INCREF(Py_None); resultobj = Py_None;
8194 return resultobj;
8195 fail:
8196 return NULL;
8197 }
8198
8199
8200 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
8201 PyObject *resultobj;
8202 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8203 PyObject * obj0 = 0 ;
8204 char *kwnames[] = {
8205 (char *) "self", NULL
8206 };
8207
8208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
8209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8210 if (SWIG_arg_fail(1)) SWIG_fail;
8211 {
8212 PyThreadState* __tstate = wxPyBeginAllowThreads();
8213 (arg1)->Init();
8214
8215 wxPyEndAllowThreads(__tstate);
8216 if (PyErr_Occurred()) SWIG_fail;
8217 }
8218 Py_INCREF(Py_None); resultobj = Py_None;
8219 return resultobj;
8220 fail:
8221 return NULL;
8222 }
8223
8224
8225 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
8226 PyObject *resultobj;
8227 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8228 wxFont *arg2 = 0 ;
8229 PyObject * obj0 = 0 ;
8230 PyObject * obj1 = 0 ;
8231 char *kwnames[] = {
8232 (char *) "self",(char *) "font", NULL
8233 };
8234
8235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
8236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8237 if (SWIG_arg_fail(1)) SWIG_fail;
8238 {
8239 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
8240 if (SWIG_arg_fail(2)) SWIG_fail;
8241 if (arg2 == NULL) {
8242 SWIG_null_ref("wxFont");
8243 }
8244 if (SWIG_arg_fail(2)) SWIG_fail;
8245 }
8246 {
8247 PyThreadState* __tstate = wxPyBeginAllowThreads();
8248 (arg1)->InitFromFont((wxFont const &)*arg2);
8249
8250 wxPyEndAllowThreads(__tstate);
8251 if (PyErr_Occurred()) SWIG_fail;
8252 }
8253 Py_INCREF(Py_None); resultobj = Py_None;
8254 return resultobj;
8255 fail:
8256 return NULL;
8257 }
8258
8259
8260 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
8261 PyObject *resultobj;
8262 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8263 int result;
8264 PyObject * obj0 = 0 ;
8265 char *kwnames[] = {
8266 (char *) "self", NULL
8267 };
8268
8269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
8270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8271 if (SWIG_arg_fail(1)) SWIG_fail;
8272 {
8273 PyThreadState* __tstate = wxPyBeginAllowThreads();
8274 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
8275
8276 wxPyEndAllowThreads(__tstate);
8277 if (PyErr_Occurred()) SWIG_fail;
8278 }
8279 {
8280 resultobj = SWIG_From_int((int)(result));
8281 }
8282 return resultobj;
8283 fail:
8284 return NULL;
8285 }
8286
8287
8288 static PyObject *_wrap_NativeFontInfo_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
8289 PyObject *resultobj;
8290 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8291 wxSize result;
8292 PyObject * obj0 = 0 ;
8293 char *kwnames[] = {
8294 (char *) "self", NULL
8295 };
8296
8297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPixelSize",kwnames,&obj0)) goto fail;
8298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8299 if (SWIG_arg_fail(1)) SWIG_fail;
8300 {
8301 PyThreadState* __tstate = wxPyBeginAllowThreads();
8302 result = ((wxNativeFontInfo const *)arg1)->GetPixelSize();
8303
8304 wxPyEndAllowThreads(__tstate);
8305 if (PyErr_Occurred()) SWIG_fail;
8306 }
8307 {
8308 wxSize * resultptr;
8309 resultptr = new wxSize((wxSize &)(result));
8310 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
8311 }
8312 return resultobj;
8313 fail:
8314 return NULL;
8315 }
8316
8317
8318 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
8319 PyObject *resultobj;
8320 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8321 wxFontStyle result;
8322 PyObject * obj0 = 0 ;
8323 char *kwnames[] = {
8324 (char *) "self", NULL
8325 };
8326
8327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
8328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8329 if (SWIG_arg_fail(1)) SWIG_fail;
8330 {
8331 PyThreadState* __tstate = wxPyBeginAllowThreads();
8332 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
8333
8334 wxPyEndAllowThreads(__tstate);
8335 if (PyErr_Occurred()) SWIG_fail;
8336 }
8337 resultobj = SWIG_From_int((result));
8338 return resultobj;
8339 fail:
8340 return NULL;
8341 }
8342
8343
8344 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
8345 PyObject *resultobj;
8346 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8347 wxFontWeight result;
8348 PyObject * obj0 = 0 ;
8349 char *kwnames[] = {
8350 (char *) "self", NULL
8351 };
8352
8353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
8354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8355 if (SWIG_arg_fail(1)) SWIG_fail;
8356 {
8357 PyThreadState* __tstate = wxPyBeginAllowThreads();
8358 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
8359
8360 wxPyEndAllowThreads(__tstate);
8361 if (PyErr_Occurred()) SWIG_fail;
8362 }
8363 resultobj = SWIG_From_int((result));
8364 return resultobj;
8365 fail:
8366 return NULL;
8367 }
8368
8369
8370 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8371 PyObject *resultobj;
8372 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8373 bool result;
8374 PyObject * obj0 = 0 ;
8375 char *kwnames[] = {
8376 (char *) "self", NULL
8377 };
8378
8379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
8380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8381 if (SWIG_arg_fail(1)) SWIG_fail;
8382 {
8383 PyThreadState* __tstate = wxPyBeginAllowThreads();
8384 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
8385
8386 wxPyEndAllowThreads(__tstate);
8387 if (PyErr_Occurred()) SWIG_fail;
8388 }
8389 {
8390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8391 }
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8399 PyObject *resultobj;
8400 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8401 wxString result;
8402 PyObject * obj0 = 0 ;
8403 char *kwnames[] = {
8404 (char *) "self", NULL
8405 };
8406
8407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
8408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8409 if (SWIG_arg_fail(1)) SWIG_fail;
8410 {
8411 PyThreadState* __tstate = wxPyBeginAllowThreads();
8412 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
8413
8414 wxPyEndAllowThreads(__tstate);
8415 if (PyErr_Occurred()) SWIG_fail;
8416 }
8417 {
8418 #if wxUSE_UNICODE
8419 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8420 #else
8421 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8422 #endif
8423 }
8424 return resultobj;
8425 fail:
8426 return NULL;
8427 }
8428
8429
8430 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8431 PyObject *resultobj;
8432 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8433 wxFontFamily result;
8434 PyObject * obj0 = 0 ;
8435 char *kwnames[] = {
8436 (char *) "self", NULL
8437 };
8438
8439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
8440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8441 if (SWIG_arg_fail(1)) SWIG_fail;
8442 {
8443 PyThreadState* __tstate = wxPyBeginAllowThreads();
8444 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
8445
8446 wxPyEndAllowThreads(__tstate);
8447 if (PyErr_Occurred()) SWIG_fail;
8448 }
8449 resultobj = SWIG_From_int((result));
8450 return resultobj;
8451 fail:
8452 return NULL;
8453 }
8454
8455
8456 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8457 PyObject *resultobj;
8458 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8459 wxFontEncoding result;
8460 PyObject * obj0 = 0 ;
8461 char *kwnames[] = {
8462 (char *) "self", NULL
8463 };
8464
8465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
8466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8467 if (SWIG_arg_fail(1)) SWIG_fail;
8468 {
8469 PyThreadState* __tstate = wxPyBeginAllowThreads();
8470 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
8471
8472 wxPyEndAllowThreads(__tstate);
8473 if (PyErr_Occurred()) SWIG_fail;
8474 }
8475 resultobj = SWIG_From_int((result));
8476 return resultobj;
8477 fail:
8478 return NULL;
8479 }
8480
8481
8482 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
8483 PyObject *resultobj;
8484 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8485 int arg2 ;
8486 PyObject * obj0 = 0 ;
8487 PyObject * obj1 = 0 ;
8488 char *kwnames[] = {
8489 (char *) "self",(char *) "pointsize", NULL
8490 };
8491
8492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
8493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8494 if (SWIG_arg_fail(1)) SWIG_fail;
8495 {
8496 arg2 = (int)(SWIG_As_int(obj1));
8497 if (SWIG_arg_fail(2)) SWIG_fail;
8498 }
8499 {
8500 PyThreadState* __tstate = wxPyBeginAllowThreads();
8501 (arg1)->SetPointSize(arg2);
8502
8503 wxPyEndAllowThreads(__tstate);
8504 if (PyErr_Occurred()) SWIG_fail;
8505 }
8506 Py_INCREF(Py_None); resultobj = Py_None;
8507 return resultobj;
8508 fail:
8509 return NULL;
8510 }
8511
8512
8513 static PyObject *_wrap_NativeFontInfo_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
8514 PyObject *resultobj;
8515 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8516 wxSize *arg2 = 0 ;
8517 wxSize temp2 ;
8518 PyObject * obj0 = 0 ;
8519 PyObject * obj1 = 0 ;
8520 char *kwnames[] = {
8521 (char *) "self",(char *) "pixelSize", NULL
8522 };
8523
8524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
8525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8526 if (SWIG_arg_fail(1)) SWIG_fail;
8527 {
8528 arg2 = &temp2;
8529 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8530 }
8531 {
8532 PyThreadState* __tstate = wxPyBeginAllowThreads();
8533 (arg1)->SetPixelSize((wxSize const &)*arg2);
8534
8535 wxPyEndAllowThreads(__tstate);
8536 if (PyErr_Occurred()) SWIG_fail;
8537 }
8538 Py_INCREF(Py_None); resultobj = Py_None;
8539 return resultobj;
8540 fail:
8541 return NULL;
8542 }
8543
8544
8545 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
8546 PyObject *resultobj;
8547 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8548 wxFontStyle arg2 ;
8549 PyObject * obj0 = 0 ;
8550 PyObject * obj1 = 0 ;
8551 char *kwnames[] = {
8552 (char *) "self",(char *) "style", NULL
8553 };
8554
8555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
8556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8557 if (SWIG_arg_fail(1)) SWIG_fail;
8558 {
8559 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
8560 if (SWIG_arg_fail(2)) SWIG_fail;
8561 }
8562 {
8563 PyThreadState* __tstate = wxPyBeginAllowThreads();
8564 (arg1)->SetStyle((wxFontStyle )arg2);
8565
8566 wxPyEndAllowThreads(__tstate);
8567 if (PyErr_Occurred()) SWIG_fail;
8568 }
8569 Py_INCREF(Py_None); resultobj = Py_None;
8570 return resultobj;
8571 fail:
8572 return NULL;
8573 }
8574
8575
8576 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
8577 PyObject *resultobj;
8578 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8579 wxFontWeight arg2 ;
8580 PyObject * obj0 = 0 ;
8581 PyObject * obj1 = 0 ;
8582 char *kwnames[] = {
8583 (char *) "self",(char *) "weight", NULL
8584 };
8585
8586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
8587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8588 if (SWIG_arg_fail(1)) SWIG_fail;
8589 {
8590 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
8591 if (SWIG_arg_fail(2)) SWIG_fail;
8592 }
8593 {
8594 PyThreadState* __tstate = wxPyBeginAllowThreads();
8595 (arg1)->SetWeight((wxFontWeight )arg2);
8596
8597 wxPyEndAllowThreads(__tstate);
8598 if (PyErr_Occurred()) SWIG_fail;
8599 }
8600 Py_INCREF(Py_None); resultobj = Py_None;
8601 return resultobj;
8602 fail:
8603 return NULL;
8604 }
8605
8606
8607 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8608 PyObject *resultobj;
8609 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8610 bool arg2 ;
8611 PyObject * obj0 = 0 ;
8612 PyObject * obj1 = 0 ;
8613 char *kwnames[] = {
8614 (char *) "self",(char *) "underlined", NULL
8615 };
8616
8617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
8618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8619 if (SWIG_arg_fail(1)) SWIG_fail;
8620 {
8621 arg2 = (bool)(SWIG_As_bool(obj1));
8622 if (SWIG_arg_fail(2)) SWIG_fail;
8623 }
8624 {
8625 PyThreadState* __tstate = wxPyBeginAllowThreads();
8626 (arg1)->SetUnderlined(arg2);
8627
8628 wxPyEndAllowThreads(__tstate);
8629 if (PyErr_Occurred()) SWIG_fail;
8630 }
8631 Py_INCREF(Py_None); resultobj = Py_None;
8632 return resultobj;
8633 fail:
8634 return NULL;
8635 }
8636
8637
8638 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8639 PyObject *resultobj;
8640 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8641 wxString arg2 ;
8642 PyObject * obj0 = 0 ;
8643 PyObject * obj1 = 0 ;
8644 char *kwnames[] = {
8645 (char *) "self",(char *) "facename", NULL
8646 };
8647
8648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
8649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8650 if (SWIG_arg_fail(1)) SWIG_fail;
8651 {
8652 wxString* sptr = wxString_in_helper(obj1);
8653 if (sptr == NULL) SWIG_fail;
8654 arg2 = *sptr;
8655 delete sptr;
8656 }
8657 {
8658 PyThreadState* __tstate = wxPyBeginAllowThreads();
8659 (arg1)->SetFaceName(arg2);
8660
8661 wxPyEndAllowThreads(__tstate);
8662 if (PyErr_Occurred()) SWIG_fail;
8663 }
8664 Py_INCREF(Py_None); resultobj = Py_None;
8665 return resultobj;
8666 fail:
8667 return NULL;
8668 }
8669
8670
8671 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8672 PyObject *resultobj;
8673 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8674 wxFontFamily arg2 ;
8675 PyObject * obj0 = 0 ;
8676 PyObject * obj1 = 0 ;
8677 char *kwnames[] = {
8678 (char *) "self",(char *) "family", NULL
8679 };
8680
8681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8683 if (SWIG_arg_fail(1)) SWIG_fail;
8684 {
8685 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8686 if (SWIG_arg_fail(2)) SWIG_fail;
8687 }
8688 {
8689 PyThreadState* __tstate = wxPyBeginAllowThreads();
8690 (arg1)->SetFamily((wxFontFamily )arg2);
8691
8692 wxPyEndAllowThreads(__tstate);
8693 if (PyErr_Occurred()) SWIG_fail;
8694 }
8695 Py_INCREF(Py_None); resultobj = Py_None;
8696 return resultobj;
8697 fail:
8698 return NULL;
8699 }
8700
8701
8702 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8703 PyObject *resultobj;
8704 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8705 wxFontEncoding arg2 ;
8706 PyObject * obj0 = 0 ;
8707 PyObject * obj1 = 0 ;
8708 char *kwnames[] = {
8709 (char *) "self",(char *) "encoding", NULL
8710 };
8711
8712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8714 if (SWIG_arg_fail(1)) SWIG_fail;
8715 {
8716 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8717 if (SWIG_arg_fail(2)) SWIG_fail;
8718 }
8719 {
8720 PyThreadState* __tstate = wxPyBeginAllowThreads();
8721 (arg1)->SetEncoding((wxFontEncoding )arg2);
8722
8723 wxPyEndAllowThreads(__tstate);
8724 if (PyErr_Occurred()) SWIG_fail;
8725 }
8726 Py_INCREF(Py_None); resultobj = Py_None;
8727 return resultobj;
8728 fail:
8729 return NULL;
8730 }
8731
8732
8733 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8734 PyObject *resultobj;
8735 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8736 wxString *arg2 = 0 ;
8737 bool result;
8738 bool temp2 = false ;
8739 PyObject * obj0 = 0 ;
8740 PyObject * obj1 = 0 ;
8741 char *kwnames[] = {
8742 (char *) "self",(char *) "s", NULL
8743 };
8744
8745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8747 if (SWIG_arg_fail(1)) SWIG_fail;
8748 {
8749 arg2 = wxString_in_helper(obj1);
8750 if (arg2 == NULL) SWIG_fail;
8751 temp2 = true;
8752 }
8753 {
8754 PyThreadState* __tstate = wxPyBeginAllowThreads();
8755 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8756
8757 wxPyEndAllowThreads(__tstate);
8758 if (PyErr_Occurred()) SWIG_fail;
8759 }
8760 {
8761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8762 }
8763 {
8764 if (temp2)
8765 delete arg2;
8766 }
8767 return resultobj;
8768 fail:
8769 {
8770 if (temp2)
8771 delete arg2;
8772 }
8773 return NULL;
8774 }
8775
8776
8777 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8778 PyObject *resultobj;
8779 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8780 wxString result;
8781 PyObject * obj0 = 0 ;
8782 char *kwnames[] = {
8783 (char *) "self", NULL
8784 };
8785
8786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8788 if (SWIG_arg_fail(1)) SWIG_fail;
8789 {
8790 PyThreadState* __tstate = wxPyBeginAllowThreads();
8791 result = ((wxNativeFontInfo const *)arg1)->ToString();
8792
8793 wxPyEndAllowThreads(__tstate);
8794 if (PyErr_Occurred()) SWIG_fail;
8795 }
8796 {
8797 #if wxUSE_UNICODE
8798 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8799 #else
8800 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8801 #endif
8802 }
8803 return resultobj;
8804 fail:
8805 return NULL;
8806 }
8807
8808
8809 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8810 PyObject *resultobj;
8811 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8812 wxString result;
8813 PyObject * obj0 = 0 ;
8814 char *kwnames[] = {
8815 (char *) "self", NULL
8816 };
8817
8818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8820 if (SWIG_arg_fail(1)) SWIG_fail;
8821 {
8822 PyThreadState* __tstate = wxPyBeginAllowThreads();
8823 result = wxNativeFontInfo___str__(arg1);
8824
8825 wxPyEndAllowThreads(__tstate);
8826 if (PyErr_Occurred()) SWIG_fail;
8827 }
8828 {
8829 #if wxUSE_UNICODE
8830 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8831 #else
8832 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8833 #endif
8834 }
8835 return resultobj;
8836 fail:
8837 return NULL;
8838 }
8839
8840
8841 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8842 PyObject *resultobj;
8843 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8844 wxString *arg2 = 0 ;
8845 bool result;
8846 bool temp2 = false ;
8847 PyObject * obj0 = 0 ;
8848 PyObject * obj1 = 0 ;
8849 char *kwnames[] = {
8850 (char *) "self",(char *) "s", NULL
8851 };
8852
8853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8855 if (SWIG_arg_fail(1)) SWIG_fail;
8856 {
8857 arg2 = wxString_in_helper(obj1);
8858 if (arg2 == NULL) SWIG_fail;
8859 temp2 = true;
8860 }
8861 {
8862 PyThreadState* __tstate = wxPyBeginAllowThreads();
8863 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8864
8865 wxPyEndAllowThreads(__tstate);
8866 if (PyErr_Occurred()) SWIG_fail;
8867 }
8868 {
8869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8870 }
8871 {
8872 if (temp2)
8873 delete arg2;
8874 }
8875 return resultobj;
8876 fail:
8877 {
8878 if (temp2)
8879 delete arg2;
8880 }
8881 return NULL;
8882 }
8883
8884
8885 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8886 PyObject *resultobj;
8887 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8888 wxString result;
8889 PyObject * obj0 = 0 ;
8890 char *kwnames[] = {
8891 (char *) "self", NULL
8892 };
8893
8894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8896 if (SWIG_arg_fail(1)) SWIG_fail;
8897 {
8898 PyThreadState* __tstate = wxPyBeginAllowThreads();
8899 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8900
8901 wxPyEndAllowThreads(__tstate);
8902 if (PyErr_Occurred()) SWIG_fail;
8903 }
8904 {
8905 #if wxUSE_UNICODE
8906 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8907 #else
8908 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8909 #endif
8910 }
8911 return resultobj;
8912 fail:
8913 return NULL;
8914 }
8915
8916
8917 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8918 PyObject *obj;
8919 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8920 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8921 Py_INCREF(obj);
8922 return Py_BuildValue((char *)"");
8923 }
8924 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8925 PyObject *resultobj;
8926 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8927 wxString *arg2 = (wxString *) 0 ;
8928 bool temp2 = false ;
8929 PyObject * obj0 = 0 ;
8930 PyObject * obj1 = 0 ;
8931 char *kwnames[] = {
8932 (char *) "self",(char *) "facename", NULL
8933 };
8934
8935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8937 if (SWIG_arg_fail(1)) SWIG_fail;
8938 {
8939 arg2 = wxString_in_helper(obj1);
8940 if (arg2 == NULL) SWIG_fail;
8941 temp2 = true;
8942 }
8943 if (arg1) (arg1)->facename = *arg2;
8944
8945 Py_INCREF(Py_None); resultobj = Py_None;
8946 {
8947 if (temp2)
8948 delete arg2;
8949 }
8950 return resultobj;
8951 fail:
8952 {
8953 if (temp2)
8954 delete arg2;
8955 }
8956 return NULL;
8957 }
8958
8959
8960 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8961 PyObject *resultobj;
8962 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8963 wxString *result;
8964 PyObject * obj0 = 0 ;
8965 char *kwnames[] = {
8966 (char *) "self", NULL
8967 };
8968
8969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
8970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8971 if (SWIG_arg_fail(1)) SWIG_fail;
8972 result = (wxString *)& ((arg1)->facename);
8973
8974 {
8975 #if wxUSE_UNICODE
8976 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8977 #else
8978 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8979 #endif
8980 }
8981 return resultobj;
8982 fail:
8983 return NULL;
8984 }
8985
8986
8987 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8988 PyObject *resultobj;
8989 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8990 wxFontEncoding arg2 ;
8991 PyObject * obj0 = 0 ;
8992 PyObject * obj1 = 0 ;
8993 char *kwnames[] = {
8994 (char *) "self",(char *) "encoding", NULL
8995 };
8996
8997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
8998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8999 if (SWIG_arg_fail(1)) SWIG_fail;
9000 {
9001 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9002 if (SWIG_arg_fail(2)) SWIG_fail;
9003 }
9004 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
9005
9006 Py_INCREF(Py_None); resultobj = Py_None;
9007 return resultobj;
9008 fail:
9009 return NULL;
9010 }
9011
9012
9013 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
9014 PyObject *resultobj;
9015 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9016 wxFontEncoding result;
9017 PyObject * obj0 = 0 ;
9018 char *kwnames[] = {
9019 (char *) "self", NULL
9020 };
9021
9022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
9023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9024 if (SWIG_arg_fail(1)) SWIG_fail;
9025 result = (wxFontEncoding) ((arg1)->encoding);
9026
9027 resultobj = SWIG_From_int((result));
9028 return resultobj;
9029 fail:
9030 return NULL;
9031 }
9032
9033
9034 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9035 PyObject *resultobj;
9036 wxNativeEncodingInfo *result;
9037 char *kwnames[] = {
9038 NULL
9039 };
9040
9041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
9042 {
9043 PyThreadState* __tstate = wxPyBeginAllowThreads();
9044 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
9045
9046 wxPyEndAllowThreads(__tstate);
9047 if (PyErr_Occurred()) SWIG_fail;
9048 }
9049 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
9050 return resultobj;
9051 fail:
9052 return NULL;
9053 }
9054
9055
9056 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9057 PyObject *resultobj;
9058 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9059 PyObject * obj0 = 0 ;
9060 char *kwnames[] = {
9061 (char *) "self", NULL
9062 };
9063
9064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
9065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9066 if (SWIG_arg_fail(1)) SWIG_fail;
9067 {
9068 PyThreadState* __tstate = wxPyBeginAllowThreads();
9069 delete arg1;
9070
9071 wxPyEndAllowThreads(__tstate);
9072 if (PyErr_Occurred()) SWIG_fail;
9073 }
9074 Py_INCREF(Py_None); resultobj = Py_None;
9075 return resultobj;
9076 fail:
9077 return NULL;
9078 }
9079
9080
9081 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
9082 PyObject *resultobj;
9083 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9084 wxString *arg2 = 0 ;
9085 bool result;
9086 bool temp2 = false ;
9087 PyObject * obj0 = 0 ;
9088 PyObject * obj1 = 0 ;
9089 char *kwnames[] = {
9090 (char *) "self",(char *) "s", NULL
9091 };
9092
9093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
9094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9095 if (SWIG_arg_fail(1)) SWIG_fail;
9096 {
9097 arg2 = wxString_in_helper(obj1);
9098 if (arg2 == NULL) SWIG_fail;
9099 temp2 = true;
9100 }
9101 {
9102 PyThreadState* __tstate = wxPyBeginAllowThreads();
9103 result = (bool)(arg1)->FromString((wxString const &)*arg2);
9104
9105 wxPyEndAllowThreads(__tstate);
9106 if (PyErr_Occurred()) SWIG_fail;
9107 }
9108 {
9109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9110 }
9111 {
9112 if (temp2)
9113 delete arg2;
9114 }
9115 return resultobj;
9116 fail:
9117 {
9118 if (temp2)
9119 delete arg2;
9120 }
9121 return NULL;
9122 }
9123
9124
9125 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
9126 PyObject *resultobj;
9127 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9128 wxString result;
9129 PyObject * obj0 = 0 ;
9130 char *kwnames[] = {
9131 (char *) "self", NULL
9132 };
9133
9134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
9135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9136 if (SWIG_arg_fail(1)) SWIG_fail;
9137 {
9138 PyThreadState* __tstate = wxPyBeginAllowThreads();
9139 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
9140
9141 wxPyEndAllowThreads(__tstate);
9142 if (PyErr_Occurred()) SWIG_fail;
9143 }
9144 {
9145 #if wxUSE_UNICODE
9146 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9147 #else
9148 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9149 #endif
9150 }
9151 return resultobj;
9152 fail:
9153 return NULL;
9154 }
9155
9156
9157 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
9158 PyObject *obj;
9159 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9160 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
9161 Py_INCREF(obj);
9162 return Py_BuildValue((char *)"");
9163 }
9164 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9165 PyObject *resultobj;
9166 wxFontEncoding arg1 ;
9167 wxNativeEncodingInfo *result;
9168 PyObject * obj0 = 0 ;
9169 char *kwnames[] = {
9170 (char *) "encoding", NULL
9171 };
9172
9173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
9174 {
9175 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9176 if (SWIG_arg_fail(1)) SWIG_fail;
9177 }
9178 {
9179 PyThreadState* __tstate = wxPyBeginAllowThreads();
9180 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
9181
9182 wxPyEndAllowThreads(__tstate);
9183 if (PyErr_Occurred()) SWIG_fail;
9184 }
9185 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
9186 return resultobj;
9187 fail:
9188 return NULL;
9189 }
9190
9191
9192 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9193 PyObject *resultobj;
9194 wxNativeEncodingInfo *arg1 = 0 ;
9195 bool result;
9196 PyObject * obj0 = 0 ;
9197 char *kwnames[] = {
9198 (char *) "info", NULL
9199 };
9200
9201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
9202 {
9203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9204 if (SWIG_arg_fail(1)) SWIG_fail;
9205 if (arg1 == NULL) {
9206 SWIG_null_ref("wxNativeEncodingInfo");
9207 }
9208 if (SWIG_arg_fail(1)) SWIG_fail;
9209 }
9210 {
9211 PyThreadState* __tstate = wxPyBeginAllowThreads();
9212 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
9213
9214 wxPyEndAllowThreads(__tstate);
9215 if (PyErr_Occurred()) SWIG_fail;
9216 }
9217 {
9218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9219 }
9220 return resultobj;
9221 fail:
9222 return NULL;
9223 }
9224
9225
9226 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
9227 PyObject *resultobj;
9228 wxFontMapper *result;
9229 char *kwnames[] = {
9230 NULL
9231 };
9232
9233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
9234 {
9235 PyThreadState* __tstate = wxPyBeginAllowThreads();
9236 result = (wxFontMapper *)new wxFontMapper();
9237
9238 wxPyEndAllowThreads(__tstate);
9239 if (PyErr_Occurred()) SWIG_fail;
9240 }
9241 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
9242 return resultobj;
9243 fail:
9244 return NULL;
9245 }
9246
9247
9248 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
9249 PyObject *resultobj;
9250 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9251 PyObject * obj0 = 0 ;
9252 char *kwnames[] = {
9253 (char *) "self", NULL
9254 };
9255
9256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
9257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9258 if (SWIG_arg_fail(1)) SWIG_fail;
9259 {
9260 PyThreadState* __tstate = wxPyBeginAllowThreads();
9261 delete arg1;
9262
9263 wxPyEndAllowThreads(__tstate);
9264 if (PyErr_Occurred()) SWIG_fail;
9265 }
9266 Py_INCREF(Py_None); resultobj = Py_None;
9267 return resultobj;
9268 fail:
9269 return NULL;
9270 }
9271
9272
9273 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
9274 PyObject *resultobj;
9275 wxFontMapper *result;
9276 char *kwnames[] = {
9277 NULL
9278 };
9279
9280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
9281 {
9282 PyThreadState* __tstate = wxPyBeginAllowThreads();
9283 result = (wxFontMapper *)wxFontMapper::Get();
9284
9285 wxPyEndAllowThreads(__tstate);
9286 if (PyErr_Occurred()) SWIG_fail;
9287 }
9288 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
9289 return resultobj;
9290 fail:
9291 return NULL;
9292 }
9293
9294
9295 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
9296 PyObject *resultobj;
9297 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9298 wxFontMapper *result;
9299 PyObject * obj0 = 0 ;
9300 char *kwnames[] = {
9301 (char *) "mapper", NULL
9302 };
9303
9304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
9305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9306 if (SWIG_arg_fail(1)) SWIG_fail;
9307 {
9308 PyThreadState* __tstate = wxPyBeginAllowThreads();
9309 result = (wxFontMapper *)wxFontMapper::Set(arg1);
9310
9311 wxPyEndAllowThreads(__tstate);
9312 if (PyErr_Occurred()) SWIG_fail;
9313 }
9314 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
9315 return resultobj;
9316 fail:
9317 return NULL;
9318 }
9319
9320
9321 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9322 PyObject *resultobj;
9323 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9324 wxString *arg2 = 0 ;
9325 bool arg3 = (bool) true ;
9326 wxFontEncoding result;
9327 bool temp2 = false ;
9328 PyObject * obj0 = 0 ;
9329 PyObject * obj1 = 0 ;
9330 PyObject * obj2 = 0 ;
9331 char *kwnames[] = {
9332 (char *) "self",(char *) "charset",(char *) "interactive", NULL
9333 };
9334
9335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
9336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9337 if (SWIG_arg_fail(1)) SWIG_fail;
9338 {
9339 arg2 = wxString_in_helper(obj1);
9340 if (arg2 == NULL) SWIG_fail;
9341 temp2 = true;
9342 }
9343 if (obj2) {
9344 {
9345 arg3 = (bool)(SWIG_As_bool(obj2));
9346 if (SWIG_arg_fail(3)) SWIG_fail;
9347 }
9348 }
9349 {
9350 PyThreadState* __tstate = wxPyBeginAllowThreads();
9351 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
9352
9353 wxPyEndAllowThreads(__tstate);
9354 if (PyErr_Occurred()) SWIG_fail;
9355 }
9356 resultobj = SWIG_From_int((result));
9357 {
9358 if (temp2)
9359 delete arg2;
9360 }
9361 return resultobj;
9362 fail:
9363 {
9364 if (temp2)
9365 delete arg2;
9366 }
9367 return NULL;
9368 }
9369
9370
9371 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
9372 PyObject *resultobj;
9373 size_t result;
9374 char *kwnames[] = {
9375 NULL
9376 };
9377
9378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
9379 {
9380 PyThreadState* __tstate = wxPyBeginAllowThreads();
9381 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
9382
9383 wxPyEndAllowThreads(__tstate);
9384 if (PyErr_Occurred()) SWIG_fail;
9385 }
9386 {
9387 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9388 }
9389 return resultobj;
9390 fail:
9391 return NULL;
9392 }
9393
9394
9395 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9396 PyObject *resultobj;
9397 size_t arg1 ;
9398 wxFontEncoding result;
9399 PyObject * obj0 = 0 ;
9400 char *kwnames[] = {
9401 (char *) "n", NULL
9402 };
9403
9404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
9405 {
9406 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
9407 if (SWIG_arg_fail(1)) SWIG_fail;
9408 }
9409 {
9410 PyThreadState* __tstate = wxPyBeginAllowThreads();
9411 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
9412
9413 wxPyEndAllowThreads(__tstate);
9414 if (PyErr_Occurred()) SWIG_fail;
9415 }
9416 resultobj = SWIG_From_int((result));
9417 return resultobj;
9418 fail:
9419 return NULL;
9420 }
9421
9422
9423 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
9424 PyObject *resultobj;
9425 wxFontEncoding arg1 ;
9426 wxString result;
9427 PyObject * obj0 = 0 ;
9428 char *kwnames[] = {
9429 (char *) "encoding", NULL
9430 };
9431
9432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
9433 {
9434 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9435 if (SWIG_arg_fail(1)) SWIG_fail;
9436 }
9437 {
9438 PyThreadState* __tstate = wxPyBeginAllowThreads();
9439 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
9440
9441 wxPyEndAllowThreads(__tstate);
9442 if (PyErr_Occurred()) SWIG_fail;
9443 }
9444 {
9445 #if wxUSE_UNICODE
9446 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9447 #else
9448 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9449 #endif
9450 }
9451 return resultobj;
9452 fail:
9453 return NULL;
9454 }
9455
9456
9457 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
9458 PyObject *resultobj;
9459 wxFontEncoding arg1 ;
9460 wxString result;
9461 PyObject * obj0 = 0 ;
9462 char *kwnames[] = {
9463 (char *) "encoding", NULL
9464 };
9465
9466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
9467 {
9468 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9469 if (SWIG_arg_fail(1)) SWIG_fail;
9470 }
9471 {
9472 PyThreadState* __tstate = wxPyBeginAllowThreads();
9473 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
9474
9475 wxPyEndAllowThreads(__tstate);
9476 if (PyErr_Occurred()) SWIG_fail;
9477 }
9478 {
9479 #if wxUSE_UNICODE
9480 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9481 #else
9482 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9483 #endif
9484 }
9485 return resultobj;
9486 fail:
9487 return NULL;
9488 }
9489
9490
9491 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
9492 PyObject *resultobj;
9493 wxString *arg1 = 0 ;
9494 wxFontEncoding result;
9495 bool temp1 = false ;
9496 PyObject * obj0 = 0 ;
9497 char *kwnames[] = {
9498 (char *) "name", NULL
9499 };
9500
9501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
9502 {
9503 arg1 = wxString_in_helper(obj0);
9504 if (arg1 == NULL) SWIG_fail;
9505 temp1 = true;
9506 }
9507 {
9508 PyThreadState* __tstate = wxPyBeginAllowThreads();
9509 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
9510
9511 wxPyEndAllowThreads(__tstate);
9512 if (PyErr_Occurred()) SWIG_fail;
9513 }
9514 resultobj = SWIG_From_int((result));
9515 {
9516 if (temp1)
9517 delete arg1;
9518 }
9519 return resultobj;
9520 fail:
9521 {
9522 if (temp1)
9523 delete arg1;
9524 }
9525 return NULL;
9526 }
9527
9528
9529 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
9530 PyObject *resultobj;
9531 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9532 wxConfigBase *arg2 = (wxConfigBase *) 0 ;
9533 PyObject * obj0 = 0 ;
9534 PyObject * obj1 = 0 ;
9535 char *kwnames[] = {
9536 (char *) "self",(char *) "config", NULL
9537 };
9538
9539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
9540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9541 if (SWIG_arg_fail(1)) SWIG_fail;
9542 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
9543 if (SWIG_arg_fail(2)) SWIG_fail;
9544 {
9545 PyThreadState* __tstate = wxPyBeginAllowThreads();
9546 (arg1)->SetConfig(arg2);
9547
9548 wxPyEndAllowThreads(__tstate);
9549 if (PyErr_Occurred()) SWIG_fail;
9550 }
9551 Py_INCREF(Py_None); resultobj = Py_None;
9552 return resultobj;
9553 fail:
9554 return NULL;
9555 }
9556
9557
9558 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
9559 PyObject *resultobj;
9560 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9561 wxString *arg2 = 0 ;
9562 bool temp2 = false ;
9563 PyObject * obj0 = 0 ;
9564 PyObject * obj1 = 0 ;
9565 char *kwnames[] = {
9566 (char *) "self",(char *) "prefix", NULL
9567 };
9568
9569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
9570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9571 if (SWIG_arg_fail(1)) SWIG_fail;
9572 {
9573 arg2 = wxString_in_helper(obj1);
9574 if (arg2 == NULL) SWIG_fail;
9575 temp2 = true;
9576 }
9577 {
9578 PyThreadState* __tstate = wxPyBeginAllowThreads();
9579 (arg1)->SetConfigPath((wxString const &)*arg2);
9580
9581 wxPyEndAllowThreads(__tstate);
9582 if (PyErr_Occurred()) SWIG_fail;
9583 }
9584 Py_INCREF(Py_None); resultobj = Py_None;
9585 {
9586 if (temp2)
9587 delete arg2;
9588 }
9589 return resultobj;
9590 fail:
9591 {
9592 if (temp2)
9593 delete arg2;
9594 }
9595 return NULL;
9596 }
9597
9598
9599 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
9600 PyObject *resultobj;
9601 wxString result;
9602 char *kwnames[] = {
9603 NULL
9604 };
9605
9606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
9607 {
9608 PyThreadState* __tstate = wxPyBeginAllowThreads();
9609 result = wxFontMapper::GetDefaultConfigPath();
9610
9611 wxPyEndAllowThreads(__tstate);
9612 if (PyErr_Occurred()) SWIG_fail;
9613 }
9614 {
9615 #if wxUSE_UNICODE
9616 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9617 #else
9618 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9619 #endif
9620 }
9621 return resultobj;
9622 fail:
9623 return NULL;
9624 }
9625
9626
9627 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9628 PyObject *resultobj;
9629 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9630 wxFontEncoding arg2 ;
9631 wxString const &arg3_defvalue = wxPyEmptyString ;
9632 wxString *arg3 = (wxString *) &arg3_defvalue ;
9633 bool arg4 = (bool) true ;
9634 PyObject *result;
9635 bool temp3 = false ;
9636 PyObject * obj0 = 0 ;
9637 PyObject * obj1 = 0 ;
9638 PyObject * obj2 = 0 ;
9639 PyObject * obj3 = 0 ;
9640 char *kwnames[] = {
9641 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
9642 };
9643
9644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9646 if (SWIG_arg_fail(1)) SWIG_fail;
9647 {
9648 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9649 if (SWIG_arg_fail(2)) SWIG_fail;
9650 }
9651 if (obj2) {
9652 {
9653 arg3 = wxString_in_helper(obj2);
9654 if (arg3 == NULL) SWIG_fail;
9655 temp3 = true;
9656 }
9657 }
9658 if (obj3) {
9659 {
9660 arg4 = (bool)(SWIG_As_bool(obj3));
9661 if (SWIG_arg_fail(4)) SWIG_fail;
9662 }
9663 }
9664 {
9665 PyThreadState* __tstate = wxPyBeginAllowThreads();
9666 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9667
9668 wxPyEndAllowThreads(__tstate);
9669 if (PyErr_Occurred()) SWIG_fail;
9670 }
9671 resultobj = result;
9672 {
9673 if (temp3)
9674 delete arg3;
9675 }
9676 return resultobj;
9677 fail:
9678 {
9679 if (temp3)
9680 delete arg3;
9681 }
9682 return NULL;
9683 }
9684
9685
9686 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9687 PyObject *resultobj;
9688 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9689 wxFontEncoding arg2 ;
9690 wxString const &arg3_defvalue = wxPyEmptyString ;
9691 wxString *arg3 = (wxString *) &arg3_defvalue ;
9692 bool result;
9693 bool temp3 = false ;
9694 PyObject * obj0 = 0 ;
9695 PyObject * obj1 = 0 ;
9696 PyObject * obj2 = 0 ;
9697 char *kwnames[] = {
9698 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9699 };
9700
9701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9703 if (SWIG_arg_fail(1)) SWIG_fail;
9704 {
9705 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9706 if (SWIG_arg_fail(2)) SWIG_fail;
9707 }
9708 if (obj2) {
9709 {
9710 arg3 = wxString_in_helper(obj2);
9711 if (arg3 == NULL) SWIG_fail;
9712 temp3 = true;
9713 }
9714 }
9715 {
9716 PyThreadState* __tstate = wxPyBeginAllowThreads();
9717 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9718
9719 wxPyEndAllowThreads(__tstate);
9720 if (PyErr_Occurred()) SWIG_fail;
9721 }
9722 {
9723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9724 }
9725 {
9726 if (temp3)
9727 delete arg3;
9728 }
9729 return resultobj;
9730 fail:
9731 {
9732 if (temp3)
9733 delete arg3;
9734 }
9735 return NULL;
9736 }
9737
9738
9739 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9740 PyObject *resultobj;
9741 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9742 wxWindow *arg2 = (wxWindow *) 0 ;
9743 PyObject * obj0 = 0 ;
9744 PyObject * obj1 = 0 ;
9745 char *kwnames[] = {
9746 (char *) "self",(char *) "parent", NULL
9747 };
9748
9749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9751 if (SWIG_arg_fail(1)) SWIG_fail;
9752 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9753 if (SWIG_arg_fail(2)) SWIG_fail;
9754 {
9755 PyThreadState* __tstate = wxPyBeginAllowThreads();
9756 (arg1)->SetDialogParent(arg2);
9757
9758 wxPyEndAllowThreads(__tstate);
9759 if (PyErr_Occurred()) SWIG_fail;
9760 }
9761 Py_INCREF(Py_None); resultobj = Py_None;
9762 return resultobj;
9763 fail:
9764 return NULL;
9765 }
9766
9767
9768 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9769 PyObject *resultobj;
9770 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9771 wxString *arg2 = 0 ;
9772 bool temp2 = false ;
9773 PyObject * obj0 = 0 ;
9774 PyObject * obj1 = 0 ;
9775 char *kwnames[] = {
9776 (char *) "self",(char *) "title", NULL
9777 };
9778
9779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9781 if (SWIG_arg_fail(1)) SWIG_fail;
9782 {
9783 arg2 = wxString_in_helper(obj1);
9784 if (arg2 == NULL) SWIG_fail;
9785 temp2 = true;
9786 }
9787 {
9788 PyThreadState* __tstate = wxPyBeginAllowThreads();
9789 (arg1)->SetDialogTitle((wxString const &)*arg2);
9790
9791 wxPyEndAllowThreads(__tstate);
9792 if (PyErr_Occurred()) SWIG_fail;
9793 }
9794 Py_INCREF(Py_None); resultobj = Py_None;
9795 {
9796 if (temp2)
9797 delete arg2;
9798 }
9799 return resultobj;
9800 fail:
9801 {
9802 if (temp2)
9803 delete arg2;
9804 }
9805 return NULL;
9806 }
9807
9808
9809 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9810 PyObject *obj;
9811 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9812 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9813 Py_INCREF(obj);
9814 return Py_BuildValue((char *)"");
9815 }
9816 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9817 PyObject *resultobj;
9818 int arg1 ;
9819 int arg2 ;
9820 int arg3 ;
9821 int arg4 ;
9822 bool arg5 = (bool) false ;
9823 wxString const &arg6_defvalue = wxPyEmptyString ;
9824 wxString *arg6 = (wxString *) &arg6_defvalue ;
9825 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9826 wxFont *result;
9827 bool temp6 = false ;
9828 PyObject * obj0 = 0 ;
9829 PyObject * obj1 = 0 ;
9830 PyObject * obj2 = 0 ;
9831 PyObject * obj3 = 0 ;
9832 PyObject * obj4 = 0 ;
9833 PyObject * obj5 = 0 ;
9834 PyObject * obj6 = 0 ;
9835 char *kwnames[] = {
9836 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9837 };
9838
9839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9840 {
9841 arg1 = (int)(SWIG_As_int(obj0));
9842 if (SWIG_arg_fail(1)) SWIG_fail;
9843 }
9844 {
9845 arg2 = (int)(SWIG_As_int(obj1));
9846 if (SWIG_arg_fail(2)) SWIG_fail;
9847 }
9848 {
9849 arg3 = (int)(SWIG_As_int(obj2));
9850 if (SWIG_arg_fail(3)) SWIG_fail;
9851 }
9852 {
9853 arg4 = (int)(SWIG_As_int(obj3));
9854 if (SWIG_arg_fail(4)) SWIG_fail;
9855 }
9856 if (obj4) {
9857 {
9858 arg5 = (bool)(SWIG_As_bool(obj4));
9859 if (SWIG_arg_fail(5)) SWIG_fail;
9860 }
9861 }
9862 if (obj5) {
9863 {
9864 arg6 = wxString_in_helper(obj5);
9865 if (arg6 == NULL) SWIG_fail;
9866 temp6 = true;
9867 }
9868 }
9869 if (obj6) {
9870 {
9871 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9872 if (SWIG_arg_fail(7)) SWIG_fail;
9873 }
9874 }
9875 {
9876 if (!wxPyCheckForApp()) SWIG_fail;
9877 PyThreadState* __tstate = wxPyBeginAllowThreads();
9878 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9879
9880 wxPyEndAllowThreads(__tstate);
9881 if (PyErr_Occurred()) SWIG_fail;
9882 }
9883 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9884 {
9885 if (temp6)
9886 delete arg6;
9887 }
9888 return resultobj;
9889 fail:
9890 {
9891 if (temp6)
9892 delete arg6;
9893 }
9894 return NULL;
9895 }
9896
9897
9898 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9899 PyObject *resultobj;
9900 wxFont *arg1 = (wxFont *) 0 ;
9901 PyObject * obj0 = 0 ;
9902 char *kwnames[] = {
9903 (char *) "self", NULL
9904 };
9905
9906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9908 if (SWIG_arg_fail(1)) SWIG_fail;
9909 {
9910 PyThreadState* __tstate = wxPyBeginAllowThreads();
9911 delete arg1;
9912
9913 wxPyEndAllowThreads(__tstate);
9914 if (PyErr_Occurred()) SWIG_fail;
9915 }
9916 Py_INCREF(Py_None); resultobj = Py_None;
9917 return resultobj;
9918 fail:
9919 return NULL;
9920 }
9921
9922
9923 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9924 PyObject *resultobj;
9925 wxNativeFontInfo *arg1 = 0 ;
9926 wxFont *result;
9927 PyObject * obj0 = 0 ;
9928 char *kwnames[] = {
9929 (char *) "info", NULL
9930 };
9931
9932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9933 {
9934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9935 if (SWIG_arg_fail(1)) SWIG_fail;
9936 if (arg1 == NULL) {
9937 SWIG_null_ref("wxNativeFontInfo");
9938 }
9939 if (SWIG_arg_fail(1)) SWIG_fail;
9940 }
9941 {
9942 if (!wxPyCheckForApp()) SWIG_fail;
9943 PyThreadState* __tstate = wxPyBeginAllowThreads();
9944 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9945
9946 wxPyEndAllowThreads(__tstate);
9947 if (PyErr_Occurred()) SWIG_fail;
9948 }
9949 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9950 return resultobj;
9951 fail:
9952 return NULL;
9953 }
9954
9955
9956 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9957 PyObject *resultobj;
9958 wxString *arg1 = 0 ;
9959 wxFont *result;
9960 bool temp1 = false ;
9961 PyObject * obj0 = 0 ;
9962 char *kwnames[] = {
9963 (char *) "info", NULL
9964 };
9965
9966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9967 {
9968 arg1 = wxString_in_helper(obj0);
9969 if (arg1 == NULL) SWIG_fail;
9970 temp1 = true;
9971 }
9972 {
9973 if (!wxPyCheckForApp()) SWIG_fail;
9974 PyThreadState* __tstate = wxPyBeginAllowThreads();
9975 result = (wxFont *)new_wxFont((wxString const &)*arg1);
9976
9977 wxPyEndAllowThreads(__tstate);
9978 if (PyErr_Occurred()) SWIG_fail;
9979 }
9980 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9981 {
9982 if (temp1)
9983 delete arg1;
9984 }
9985 return resultobj;
9986 fail:
9987 {
9988 if (temp1)
9989 delete arg1;
9990 }
9991 return NULL;
9992 }
9993
9994
9995 static PyObject *_wrap_new_Font2(PyObject *, PyObject *args, PyObject *kwargs) {
9996 PyObject *resultobj;
9997 int arg1 ;
9998 wxFontFamily arg2 ;
9999 int arg3 = (int) wxFONTFLAG_DEFAULT ;
10000 wxString const &arg4_defvalue = wxPyEmptyString ;
10001 wxString *arg4 = (wxString *) &arg4_defvalue ;
10002 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
10003 wxFont *result;
10004 bool temp4 = false ;
10005 PyObject * obj0 = 0 ;
10006 PyObject * obj1 = 0 ;
10007 PyObject * obj2 = 0 ;
10008 PyObject * obj3 = 0 ;
10009 PyObject * obj4 = 0 ;
10010 char *kwnames[] = {
10011 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
10012 };
10013
10014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_Font2",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
10015 {
10016 arg1 = (int)(SWIG_As_int(obj0));
10017 if (SWIG_arg_fail(1)) SWIG_fail;
10018 }
10019 {
10020 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
10021 if (SWIG_arg_fail(2)) SWIG_fail;
10022 }
10023 if (obj2) {
10024 {
10025 arg3 = (int)(SWIG_As_int(obj2));
10026 if (SWIG_arg_fail(3)) SWIG_fail;
10027 }
10028 }
10029 if (obj3) {
10030 {
10031 arg4 = wxString_in_helper(obj3);
10032 if (arg4 == NULL) SWIG_fail;
10033 temp4 = true;
10034 }
10035 }
10036 if (obj4) {
10037 {
10038 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
10039 if (SWIG_arg_fail(5)) SWIG_fail;
10040 }
10041 }
10042 {
10043 if (!wxPyCheckForApp()) SWIG_fail;
10044 PyThreadState* __tstate = wxPyBeginAllowThreads();
10045 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
10046
10047 wxPyEndAllowThreads(__tstate);
10048 if (PyErr_Occurred()) SWIG_fail;
10049 }
10050 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10051 {
10052 if (temp4)
10053 delete arg4;
10054 }
10055 return resultobj;
10056 fail:
10057 {
10058 if (temp4)
10059 delete arg4;
10060 }
10061 return NULL;
10062 }
10063
10064
10065 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10066 PyObject *resultobj;
10067 wxSize *arg1 = 0 ;
10068 int arg2 ;
10069 int arg3 ;
10070 int arg4 ;
10071 bool arg5 = (bool) false ;
10072 wxString const &arg6_defvalue = wxEmptyString ;
10073 wxString *arg6 = (wxString *) &arg6_defvalue ;
10074 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
10075 wxFont *result;
10076 wxSize temp1 ;
10077 bool temp6 = false ;
10078 PyObject * obj0 = 0 ;
10079 PyObject * obj1 = 0 ;
10080 PyObject * obj2 = 0 ;
10081 PyObject * obj3 = 0 ;
10082 PyObject * obj4 = 0 ;
10083 PyObject * obj5 = 0 ;
10084 PyObject * obj6 = 0 ;
10085 char *kwnames[] = {
10086 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
10087 };
10088
10089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
10090 {
10091 arg1 = &temp1;
10092 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
10093 }
10094 {
10095 arg2 = (int)(SWIG_As_int(obj1));
10096 if (SWIG_arg_fail(2)) SWIG_fail;
10097 }
10098 {
10099 arg3 = (int)(SWIG_As_int(obj2));
10100 if (SWIG_arg_fail(3)) SWIG_fail;
10101 }
10102 {
10103 arg4 = (int)(SWIG_As_int(obj3));
10104 if (SWIG_arg_fail(4)) SWIG_fail;
10105 }
10106 if (obj4) {
10107 {
10108 arg5 = (bool)(SWIG_As_bool(obj4));
10109 if (SWIG_arg_fail(5)) SWIG_fail;
10110 }
10111 }
10112 if (obj5) {
10113 {
10114 arg6 = wxString_in_helper(obj5);
10115 if (arg6 == NULL) SWIG_fail;
10116 temp6 = true;
10117 }
10118 }
10119 if (obj6) {
10120 {
10121 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
10122 if (SWIG_arg_fail(7)) SWIG_fail;
10123 }
10124 }
10125 {
10126 if (!wxPyCheckForApp()) SWIG_fail;
10127 PyThreadState* __tstate = wxPyBeginAllowThreads();
10128 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
10129
10130 wxPyEndAllowThreads(__tstate);
10131 if (PyErr_Occurred()) SWIG_fail;
10132 }
10133 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10134 {
10135 if (temp6)
10136 delete arg6;
10137 }
10138 return resultobj;
10139 fail:
10140 {
10141 if (temp6)
10142 delete arg6;
10143 }
10144 return NULL;
10145 }
10146
10147
10148 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
10149 PyObject *resultobj;
10150 wxFont *arg1 = (wxFont *) 0 ;
10151 bool result;
10152 PyObject * obj0 = 0 ;
10153 char *kwnames[] = {
10154 (char *) "self", NULL
10155 };
10156
10157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
10158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10159 if (SWIG_arg_fail(1)) SWIG_fail;
10160 {
10161 PyThreadState* __tstate = wxPyBeginAllowThreads();
10162 result = (bool)((wxFont const *)arg1)->Ok();
10163
10164 wxPyEndAllowThreads(__tstate);
10165 if (PyErr_Occurred()) SWIG_fail;
10166 }
10167 {
10168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10169 }
10170 return resultobj;
10171 fail:
10172 return NULL;
10173 }
10174
10175
10176 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
10177 PyObject *resultobj;
10178 wxFont *arg1 = (wxFont *) 0 ;
10179 wxFont *arg2 = (wxFont *) 0 ;
10180 bool result;
10181 PyObject * obj0 = 0 ;
10182 PyObject * obj1 = 0 ;
10183 char *kwnames[] = {
10184 (char *) "self",(char *) "other", NULL
10185 };
10186
10187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
10188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10189 if (SWIG_arg_fail(1)) SWIG_fail;
10190 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10191 if (SWIG_arg_fail(2)) SWIG_fail;
10192 {
10193 PyThreadState* __tstate = wxPyBeginAllowThreads();
10194 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
10195
10196 wxPyEndAllowThreads(__tstate);
10197 if (PyErr_Occurred()) SWIG_fail;
10198 }
10199 {
10200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10201 }
10202 return resultobj;
10203 fail:
10204 return NULL;
10205 }
10206
10207
10208 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
10209 PyObject *resultobj;
10210 wxFont *arg1 = (wxFont *) 0 ;
10211 wxFont *arg2 = (wxFont *) 0 ;
10212 bool result;
10213 PyObject * obj0 = 0 ;
10214 PyObject * obj1 = 0 ;
10215 char *kwnames[] = {
10216 (char *) "self",(char *) "other", NULL
10217 };
10218
10219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
10220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10221 if (SWIG_arg_fail(1)) SWIG_fail;
10222 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10223 if (SWIG_arg_fail(2)) SWIG_fail;
10224 {
10225 PyThreadState* __tstate = wxPyBeginAllowThreads();
10226 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
10227
10228 wxPyEndAllowThreads(__tstate);
10229 if (PyErr_Occurred()) SWIG_fail;
10230 }
10231 {
10232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10233 }
10234 return resultobj;
10235 fail:
10236 return NULL;
10237 }
10238
10239
10240 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10241 PyObject *resultobj;
10242 wxFont *arg1 = (wxFont *) 0 ;
10243 int result;
10244 PyObject * obj0 = 0 ;
10245 char *kwnames[] = {
10246 (char *) "self", NULL
10247 };
10248
10249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
10250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10251 if (SWIG_arg_fail(1)) SWIG_fail;
10252 {
10253 PyThreadState* __tstate = wxPyBeginAllowThreads();
10254 result = (int)((wxFont const *)arg1)->GetPointSize();
10255
10256 wxPyEndAllowThreads(__tstate);
10257 if (PyErr_Occurred()) SWIG_fail;
10258 }
10259 {
10260 resultobj = SWIG_From_int((int)(result));
10261 }
10262 return resultobj;
10263 fail:
10264 return NULL;
10265 }
10266
10267
10268 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10269 PyObject *resultobj;
10270 wxFont *arg1 = (wxFont *) 0 ;
10271 wxSize result;
10272 PyObject * obj0 = 0 ;
10273 char *kwnames[] = {
10274 (char *) "self", NULL
10275 };
10276
10277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
10278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10279 if (SWIG_arg_fail(1)) SWIG_fail;
10280 {
10281 PyThreadState* __tstate = wxPyBeginAllowThreads();
10282 result = ((wxFont const *)arg1)->GetPixelSize();
10283
10284 wxPyEndAllowThreads(__tstate);
10285 if (PyErr_Occurred()) SWIG_fail;
10286 }
10287 {
10288 wxSize * resultptr;
10289 resultptr = new wxSize((wxSize &)(result));
10290 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
10291 }
10292 return resultobj;
10293 fail:
10294 return NULL;
10295 }
10296
10297
10298 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
10299 PyObject *resultobj;
10300 wxFont *arg1 = (wxFont *) 0 ;
10301 bool result;
10302 PyObject * obj0 = 0 ;
10303 char *kwnames[] = {
10304 (char *) "self", NULL
10305 };
10306
10307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
10308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10309 if (SWIG_arg_fail(1)) SWIG_fail;
10310 {
10311 PyThreadState* __tstate = wxPyBeginAllowThreads();
10312 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
10313
10314 wxPyEndAllowThreads(__tstate);
10315 if (PyErr_Occurred()) SWIG_fail;
10316 }
10317 {
10318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10319 }
10320 return resultobj;
10321 fail:
10322 return NULL;
10323 }
10324
10325
10326 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10327 PyObject *resultobj;
10328 wxFont *arg1 = (wxFont *) 0 ;
10329 int result;
10330 PyObject * obj0 = 0 ;
10331 char *kwnames[] = {
10332 (char *) "self", NULL
10333 };
10334
10335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
10336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10337 if (SWIG_arg_fail(1)) SWIG_fail;
10338 {
10339 PyThreadState* __tstate = wxPyBeginAllowThreads();
10340 result = (int)((wxFont const *)arg1)->GetFamily();
10341
10342 wxPyEndAllowThreads(__tstate);
10343 if (PyErr_Occurred()) SWIG_fail;
10344 }
10345 {
10346 resultobj = SWIG_From_int((int)(result));
10347 }
10348 return resultobj;
10349 fail:
10350 return NULL;
10351 }
10352
10353
10354 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10355 PyObject *resultobj;
10356 wxFont *arg1 = (wxFont *) 0 ;
10357 int result;
10358 PyObject * obj0 = 0 ;
10359 char *kwnames[] = {
10360 (char *) "self", NULL
10361 };
10362
10363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
10364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10365 if (SWIG_arg_fail(1)) SWIG_fail;
10366 {
10367 PyThreadState* __tstate = wxPyBeginAllowThreads();
10368 result = (int)((wxFont const *)arg1)->GetStyle();
10369
10370 wxPyEndAllowThreads(__tstate);
10371 if (PyErr_Occurred()) SWIG_fail;
10372 }
10373 {
10374 resultobj = SWIG_From_int((int)(result));
10375 }
10376 return resultobj;
10377 fail:
10378 return NULL;
10379 }
10380
10381
10382 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10383 PyObject *resultobj;
10384 wxFont *arg1 = (wxFont *) 0 ;
10385 int result;
10386 PyObject * obj0 = 0 ;
10387 char *kwnames[] = {
10388 (char *) "self", NULL
10389 };
10390
10391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
10392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10393 if (SWIG_arg_fail(1)) SWIG_fail;
10394 {
10395 PyThreadState* __tstate = wxPyBeginAllowThreads();
10396 result = (int)((wxFont const *)arg1)->GetWeight();
10397
10398 wxPyEndAllowThreads(__tstate);
10399 if (PyErr_Occurred()) SWIG_fail;
10400 }
10401 {
10402 resultobj = SWIG_From_int((int)(result));
10403 }
10404 return resultobj;
10405 fail:
10406 return NULL;
10407 }
10408
10409
10410 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10411 PyObject *resultobj;
10412 wxFont *arg1 = (wxFont *) 0 ;
10413 bool result;
10414 PyObject * obj0 = 0 ;
10415 char *kwnames[] = {
10416 (char *) "self", NULL
10417 };
10418
10419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
10420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10421 if (SWIG_arg_fail(1)) SWIG_fail;
10422 {
10423 PyThreadState* __tstate = wxPyBeginAllowThreads();
10424 result = (bool)((wxFont const *)arg1)->GetUnderlined();
10425
10426 wxPyEndAllowThreads(__tstate);
10427 if (PyErr_Occurred()) SWIG_fail;
10428 }
10429 {
10430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10431 }
10432 return resultobj;
10433 fail:
10434 return NULL;
10435 }
10436
10437
10438 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10439 PyObject *resultobj;
10440 wxFont *arg1 = (wxFont *) 0 ;
10441 wxString result;
10442 PyObject * obj0 = 0 ;
10443 char *kwnames[] = {
10444 (char *) "self", NULL
10445 };
10446
10447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
10448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10449 if (SWIG_arg_fail(1)) SWIG_fail;
10450 {
10451 PyThreadState* __tstate = wxPyBeginAllowThreads();
10452 result = ((wxFont const *)arg1)->GetFaceName();
10453
10454 wxPyEndAllowThreads(__tstate);
10455 if (PyErr_Occurred()) SWIG_fail;
10456 }
10457 {
10458 #if wxUSE_UNICODE
10459 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10460 #else
10461 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10462 #endif
10463 }
10464 return resultobj;
10465 fail:
10466 return NULL;
10467 }
10468
10469
10470 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10471 PyObject *resultobj;
10472 wxFont *arg1 = (wxFont *) 0 ;
10473 wxFontEncoding result;
10474 PyObject * obj0 = 0 ;
10475 char *kwnames[] = {
10476 (char *) "self", NULL
10477 };
10478
10479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
10480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10481 if (SWIG_arg_fail(1)) SWIG_fail;
10482 {
10483 PyThreadState* __tstate = wxPyBeginAllowThreads();
10484 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
10485
10486 wxPyEndAllowThreads(__tstate);
10487 if (PyErr_Occurred()) SWIG_fail;
10488 }
10489 resultobj = SWIG_From_int((result));
10490 return resultobj;
10491 fail:
10492 return NULL;
10493 }
10494
10495
10496 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10497 PyObject *resultobj;
10498 wxFont *arg1 = (wxFont *) 0 ;
10499 wxNativeFontInfo *result;
10500 PyObject * obj0 = 0 ;
10501 char *kwnames[] = {
10502 (char *) "self", NULL
10503 };
10504
10505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
10506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10507 if (SWIG_arg_fail(1)) SWIG_fail;
10508 {
10509 PyThreadState* __tstate = wxPyBeginAllowThreads();
10510 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
10511
10512 wxPyEndAllowThreads(__tstate);
10513 if (PyErr_Occurred()) SWIG_fail;
10514 }
10515 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
10516 return resultobj;
10517 fail:
10518 return NULL;
10519 }
10520
10521
10522 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
10523 PyObject *resultobj;
10524 wxFont *arg1 = (wxFont *) 0 ;
10525 bool result;
10526 PyObject * obj0 = 0 ;
10527 char *kwnames[] = {
10528 (char *) "self", NULL
10529 };
10530
10531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
10532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10533 if (SWIG_arg_fail(1)) SWIG_fail;
10534 {
10535 PyThreadState* __tstate = wxPyBeginAllowThreads();
10536 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
10537
10538 wxPyEndAllowThreads(__tstate);
10539 if (PyErr_Occurred()) SWIG_fail;
10540 }
10541 {
10542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10543 }
10544 return resultobj;
10545 fail:
10546 return NULL;
10547 }
10548
10549
10550 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10551 PyObject *resultobj;
10552 wxFont *arg1 = (wxFont *) 0 ;
10553 wxString result;
10554 PyObject * obj0 = 0 ;
10555 char *kwnames[] = {
10556 (char *) "self", NULL
10557 };
10558
10559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
10560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10561 if (SWIG_arg_fail(1)) SWIG_fail;
10562 {
10563 PyThreadState* __tstate = wxPyBeginAllowThreads();
10564 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
10565
10566 wxPyEndAllowThreads(__tstate);
10567 if (PyErr_Occurred()) SWIG_fail;
10568 }
10569 {
10570 #if wxUSE_UNICODE
10571 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10572 #else
10573 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10574 #endif
10575 }
10576 return resultobj;
10577 fail:
10578 return NULL;
10579 }
10580
10581
10582 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10583 PyObject *resultobj;
10584 wxFont *arg1 = (wxFont *) 0 ;
10585 wxString result;
10586 PyObject * obj0 = 0 ;
10587 char *kwnames[] = {
10588 (char *) "self", NULL
10589 };
10590
10591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
10592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10593 if (SWIG_arg_fail(1)) SWIG_fail;
10594 {
10595 PyThreadState* __tstate = wxPyBeginAllowThreads();
10596 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
10597
10598 wxPyEndAllowThreads(__tstate);
10599 if (PyErr_Occurred()) SWIG_fail;
10600 }
10601 {
10602 #if wxUSE_UNICODE
10603 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10604 #else
10605 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10606 #endif
10607 }
10608 return resultobj;
10609 fail:
10610 return NULL;
10611 }
10612
10613
10614 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10615 PyObject *resultobj;
10616 wxFont *arg1 = (wxFont *) 0 ;
10617 int arg2 ;
10618 PyObject * obj0 = 0 ;
10619 PyObject * obj1 = 0 ;
10620 char *kwnames[] = {
10621 (char *) "self",(char *) "pointSize", NULL
10622 };
10623
10624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
10625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10626 if (SWIG_arg_fail(1)) SWIG_fail;
10627 {
10628 arg2 = (int)(SWIG_As_int(obj1));
10629 if (SWIG_arg_fail(2)) SWIG_fail;
10630 }
10631 {
10632 PyThreadState* __tstate = wxPyBeginAllowThreads();
10633 (arg1)->SetPointSize(arg2);
10634
10635 wxPyEndAllowThreads(__tstate);
10636 if (PyErr_Occurred()) SWIG_fail;
10637 }
10638 Py_INCREF(Py_None); resultobj = Py_None;
10639 return resultobj;
10640 fail:
10641 return NULL;
10642 }
10643
10644
10645 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10646 PyObject *resultobj;
10647 wxFont *arg1 = (wxFont *) 0 ;
10648 wxSize *arg2 = 0 ;
10649 wxSize temp2 ;
10650 PyObject * obj0 = 0 ;
10651 PyObject * obj1 = 0 ;
10652 char *kwnames[] = {
10653 (char *) "self",(char *) "pixelSize", NULL
10654 };
10655
10656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10658 if (SWIG_arg_fail(1)) SWIG_fail;
10659 {
10660 arg2 = &temp2;
10661 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10662 }
10663 {
10664 PyThreadState* __tstate = wxPyBeginAllowThreads();
10665 (arg1)->SetPixelSize((wxSize const &)*arg2);
10666
10667 wxPyEndAllowThreads(__tstate);
10668 if (PyErr_Occurred()) SWIG_fail;
10669 }
10670 Py_INCREF(Py_None); resultobj = Py_None;
10671 return resultobj;
10672 fail:
10673 return NULL;
10674 }
10675
10676
10677 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10678 PyObject *resultobj;
10679 wxFont *arg1 = (wxFont *) 0 ;
10680 int arg2 ;
10681 PyObject * obj0 = 0 ;
10682 PyObject * obj1 = 0 ;
10683 char *kwnames[] = {
10684 (char *) "self",(char *) "family", NULL
10685 };
10686
10687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10689 if (SWIG_arg_fail(1)) SWIG_fail;
10690 {
10691 arg2 = (int)(SWIG_As_int(obj1));
10692 if (SWIG_arg_fail(2)) SWIG_fail;
10693 }
10694 {
10695 PyThreadState* __tstate = wxPyBeginAllowThreads();
10696 (arg1)->SetFamily(arg2);
10697
10698 wxPyEndAllowThreads(__tstate);
10699 if (PyErr_Occurred()) SWIG_fail;
10700 }
10701 Py_INCREF(Py_None); resultobj = Py_None;
10702 return resultobj;
10703 fail:
10704 return NULL;
10705 }
10706
10707
10708 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10709 PyObject *resultobj;
10710 wxFont *arg1 = (wxFont *) 0 ;
10711 int arg2 ;
10712 PyObject * obj0 = 0 ;
10713 PyObject * obj1 = 0 ;
10714 char *kwnames[] = {
10715 (char *) "self",(char *) "style", NULL
10716 };
10717
10718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10720 if (SWIG_arg_fail(1)) SWIG_fail;
10721 {
10722 arg2 = (int)(SWIG_As_int(obj1));
10723 if (SWIG_arg_fail(2)) SWIG_fail;
10724 }
10725 {
10726 PyThreadState* __tstate = wxPyBeginAllowThreads();
10727 (arg1)->SetStyle(arg2);
10728
10729 wxPyEndAllowThreads(__tstate);
10730 if (PyErr_Occurred()) SWIG_fail;
10731 }
10732 Py_INCREF(Py_None); resultobj = Py_None;
10733 return resultobj;
10734 fail:
10735 return NULL;
10736 }
10737
10738
10739 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10740 PyObject *resultobj;
10741 wxFont *arg1 = (wxFont *) 0 ;
10742 int arg2 ;
10743 PyObject * obj0 = 0 ;
10744 PyObject * obj1 = 0 ;
10745 char *kwnames[] = {
10746 (char *) "self",(char *) "weight", NULL
10747 };
10748
10749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10751 if (SWIG_arg_fail(1)) SWIG_fail;
10752 {
10753 arg2 = (int)(SWIG_As_int(obj1));
10754 if (SWIG_arg_fail(2)) SWIG_fail;
10755 }
10756 {
10757 PyThreadState* __tstate = wxPyBeginAllowThreads();
10758 (arg1)->SetWeight(arg2);
10759
10760 wxPyEndAllowThreads(__tstate);
10761 if (PyErr_Occurred()) SWIG_fail;
10762 }
10763 Py_INCREF(Py_None); resultobj = Py_None;
10764 return resultobj;
10765 fail:
10766 return NULL;
10767 }
10768
10769
10770 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10771 PyObject *resultobj;
10772 wxFont *arg1 = (wxFont *) 0 ;
10773 wxString *arg2 = 0 ;
10774 bool temp2 = false ;
10775 PyObject * obj0 = 0 ;
10776 PyObject * obj1 = 0 ;
10777 char *kwnames[] = {
10778 (char *) "self",(char *) "faceName", NULL
10779 };
10780
10781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10783 if (SWIG_arg_fail(1)) SWIG_fail;
10784 {
10785 arg2 = wxString_in_helper(obj1);
10786 if (arg2 == NULL) SWIG_fail;
10787 temp2 = true;
10788 }
10789 {
10790 PyThreadState* __tstate = wxPyBeginAllowThreads();
10791 (arg1)->SetFaceName((wxString const &)*arg2);
10792
10793 wxPyEndAllowThreads(__tstate);
10794 if (PyErr_Occurred()) SWIG_fail;
10795 }
10796 Py_INCREF(Py_None); resultobj = Py_None;
10797 {
10798 if (temp2)
10799 delete arg2;
10800 }
10801 return resultobj;
10802 fail:
10803 {
10804 if (temp2)
10805 delete arg2;
10806 }
10807 return NULL;
10808 }
10809
10810
10811 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10812 PyObject *resultobj;
10813 wxFont *arg1 = (wxFont *) 0 ;
10814 bool arg2 ;
10815 PyObject * obj0 = 0 ;
10816 PyObject * obj1 = 0 ;
10817 char *kwnames[] = {
10818 (char *) "self",(char *) "underlined", NULL
10819 };
10820
10821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10823 if (SWIG_arg_fail(1)) SWIG_fail;
10824 {
10825 arg2 = (bool)(SWIG_As_bool(obj1));
10826 if (SWIG_arg_fail(2)) SWIG_fail;
10827 }
10828 {
10829 PyThreadState* __tstate = wxPyBeginAllowThreads();
10830 (arg1)->SetUnderlined(arg2);
10831
10832 wxPyEndAllowThreads(__tstate);
10833 if (PyErr_Occurred()) SWIG_fail;
10834 }
10835 Py_INCREF(Py_None); resultobj = Py_None;
10836 return resultobj;
10837 fail:
10838 return NULL;
10839 }
10840
10841
10842 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10843 PyObject *resultobj;
10844 wxFont *arg1 = (wxFont *) 0 ;
10845 wxFontEncoding arg2 ;
10846 PyObject * obj0 = 0 ;
10847 PyObject * obj1 = 0 ;
10848 char *kwnames[] = {
10849 (char *) "self",(char *) "encoding", NULL
10850 };
10851
10852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10854 if (SWIG_arg_fail(1)) SWIG_fail;
10855 {
10856 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10857 if (SWIG_arg_fail(2)) SWIG_fail;
10858 }
10859 {
10860 PyThreadState* __tstate = wxPyBeginAllowThreads();
10861 (arg1)->SetEncoding((wxFontEncoding )arg2);
10862
10863 wxPyEndAllowThreads(__tstate);
10864 if (PyErr_Occurred()) SWIG_fail;
10865 }
10866 Py_INCREF(Py_None); resultobj = Py_None;
10867 return resultobj;
10868 fail:
10869 return NULL;
10870 }
10871
10872
10873 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10874 PyObject *resultobj;
10875 wxFont *arg1 = (wxFont *) 0 ;
10876 wxNativeFontInfo *arg2 = 0 ;
10877 PyObject * obj0 = 0 ;
10878 PyObject * obj1 = 0 ;
10879 char *kwnames[] = {
10880 (char *) "self",(char *) "info", NULL
10881 };
10882
10883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10885 if (SWIG_arg_fail(1)) SWIG_fail;
10886 {
10887 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10888 if (SWIG_arg_fail(2)) SWIG_fail;
10889 if (arg2 == NULL) {
10890 SWIG_null_ref("wxNativeFontInfo");
10891 }
10892 if (SWIG_arg_fail(2)) SWIG_fail;
10893 }
10894 {
10895 PyThreadState* __tstate = wxPyBeginAllowThreads();
10896 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10897
10898 wxPyEndAllowThreads(__tstate);
10899 if (PyErr_Occurred()) SWIG_fail;
10900 }
10901 Py_INCREF(Py_None); resultobj = Py_None;
10902 return resultobj;
10903 fail:
10904 return NULL;
10905 }
10906
10907
10908 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10909 PyObject *resultobj;
10910 wxFont *arg1 = (wxFont *) 0 ;
10911 wxString *arg2 = 0 ;
10912 bool temp2 = false ;
10913 PyObject * obj0 = 0 ;
10914 PyObject * obj1 = 0 ;
10915 char *kwnames[] = {
10916 (char *) "self",(char *) "info", NULL
10917 };
10918
10919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10921 if (SWIG_arg_fail(1)) SWIG_fail;
10922 {
10923 arg2 = wxString_in_helper(obj1);
10924 if (arg2 == NULL) SWIG_fail;
10925 temp2 = true;
10926 }
10927 {
10928 PyThreadState* __tstate = wxPyBeginAllowThreads();
10929 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10930
10931 wxPyEndAllowThreads(__tstate);
10932 if (PyErr_Occurred()) SWIG_fail;
10933 }
10934 Py_INCREF(Py_None); resultobj = Py_None;
10935 {
10936 if (temp2)
10937 delete arg2;
10938 }
10939 return resultobj;
10940 fail:
10941 {
10942 if (temp2)
10943 delete arg2;
10944 }
10945 return NULL;
10946 }
10947
10948
10949 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10950 PyObject *resultobj;
10951 wxFont *arg1 = (wxFont *) 0 ;
10952 wxString *arg2 = 0 ;
10953 bool temp2 = false ;
10954 PyObject * obj0 = 0 ;
10955 PyObject * obj1 = 0 ;
10956 char *kwnames[] = {
10957 (char *) "self",(char *) "info", NULL
10958 };
10959
10960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10962 if (SWIG_arg_fail(1)) SWIG_fail;
10963 {
10964 arg2 = wxString_in_helper(obj1);
10965 if (arg2 == NULL) SWIG_fail;
10966 temp2 = true;
10967 }
10968 {
10969 PyThreadState* __tstate = wxPyBeginAllowThreads();
10970 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
10971
10972 wxPyEndAllowThreads(__tstate);
10973 if (PyErr_Occurred()) SWIG_fail;
10974 }
10975 Py_INCREF(Py_None); resultobj = Py_None;
10976 {
10977 if (temp2)
10978 delete arg2;
10979 }
10980 return resultobj;
10981 fail:
10982 {
10983 if (temp2)
10984 delete arg2;
10985 }
10986 return NULL;
10987 }
10988
10989
10990 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
10991 PyObject *resultobj;
10992 wxFont *arg1 = (wxFont *) 0 ;
10993 wxString result;
10994 PyObject * obj0 = 0 ;
10995 char *kwnames[] = {
10996 (char *) "self", NULL
10997 };
10998
10999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
11000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11001 if (SWIG_arg_fail(1)) SWIG_fail;
11002 {
11003 PyThreadState* __tstate = wxPyBeginAllowThreads();
11004 result = ((wxFont const *)arg1)->GetFamilyString();
11005
11006 wxPyEndAllowThreads(__tstate);
11007 if (PyErr_Occurred()) SWIG_fail;
11008 }
11009 {
11010 #if wxUSE_UNICODE
11011 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11012 #else
11013 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11014 #endif
11015 }
11016 return resultobj;
11017 fail:
11018 return NULL;
11019 }
11020
11021
11022 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
11023 PyObject *resultobj;
11024 wxFont *arg1 = (wxFont *) 0 ;
11025 wxString result;
11026 PyObject * obj0 = 0 ;
11027 char *kwnames[] = {
11028 (char *) "self", NULL
11029 };
11030
11031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
11032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11033 if (SWIG_arg_fail(1)) SWIG_fail;
11034 {
11035 PyThreadState* __tstate = wxPyBeginAllowThreads();
11036 result = ((wxFont const *)arg1)->GetStyleString();
11037
11038 wxPyEndAllowThreads(__tstate);
11039 if (PyErr_Occurred()) SWIG_fail;
11040 }
11041 {
11042 #if wxUSE_UNICODE
11043 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11044 #else
11045 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11046 #endif
11047 }
11048 return resultobj;
11049 fail:
11050 return NULL;
11051 }
11052
11053
11054 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
11055 PyObject *resultobj;
11056 wxFont *arg1 = (wxFont *) 0 ;
11057 wxString result;
11058 PyObject * obj0 = 0 ;
11059 char *kwnames[] = {
11060 (char *) "self", NULL
11061 };
11062
11063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
11064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11065 if (SWIG_arg_fail(1)) SWIG_fail;
11066 {
11067 PyThreadState* __tstate = wxPyBeginAllowThreads();
11068 result = ((wxFont const *)arg1)->GetWeightString();
11069
11070 wxPyEndAllowThreads(__tstate);
11071 if (PyErr_Occurred()) SWIG_fail;
11072 }
11073 {
11074 #if wxUSE_UNICODE
11075 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11076 #else
11077 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11078 #endif
11079 }
11080 return resultobj;
11081 fail:
11082 return NULL;
11083 }
11084
11085
11086 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
11087 PyObject *resultobj;
11088 wxFont *arg1 = (wxFont *) 0 ;
11089 bool arg2 = (bool) true ;
11090 PyObject * obj0 = 0 ;
11091 PyObject * obj1 = 0 ;
11092 char *kwnames[] = {
11093 (char *) "self",(char *) "no", NULL
11094 };
11095
11096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
11097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11098 if (SWIG_arg_fail(1)) SWIG_fail;
11099 if (obj1) {
11100 {
11101 arg2 = (bool)(SWIG_As_bool(obj1));
11102 if (SWIG_arg_fail(2)) SWIG_fail;
11103 }
11104 }
11105 {
11106 PyThreadState* __tstate = wxPyBeginAllowThreads();
11107 (arg1)->SetNoAntiAliasing(arg2);
11108
11109 wxPyEndAllowThreads(__tstate);
11110 if (PyErr_Occurred()) SWIG_fail;
11111 }
11112 Py_INCREF(Py_None); resultobj = Py_None;
11113 return resultobj;
11114 fail:
11115 return NULL;
11116 }
11117
11118
11119 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
11120 PyObject *resultobj;
11121 wxFont *arg1 = (wxFont *) 0 ;
11122 bool result;
11123 PyObject * obj0 = 0 ;
11124 char *kwnames[] = {
11125 (char *) "self", NULL
11126 };
11127
11128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
11129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11130 if (SWIG_arg_fail(1)) SWIG_fail;
11131 {
11132 PyThreadState* __tstate = wxPyBeginAllowThreads();
11133 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
11134
11135 wxPyEndAllowThreads(__tstate);
11136 if (PyErr_Occurred()) SWIG_fail;
11137 }
11138 {
11139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11140 }
11141 return resultobj;
11142 fail:
11143 return NULL;
11144 }
11145
11146
11147 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11148 PyObject *resultobj;
11149 wxFontEncoding result;
11150 char *kwnames[] = {
11151 NULL
11152 };
11153
11154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
11155 {
11156 if (!wxPyCheckForApp()) SWIG_fail;
11157 PyThreadState* __tstate = wxPyBeginAllowThreads();
11158 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
11159
11160 wxPyEndAllowThreads(__tstate);
11161 if (PyErr_Occurred()) SWIG_fail;
11162 }
11163 resultobj = SWIG_From_int((result));
11164 return resultobj;
11165 fail:
11166 return NULL;
11167 }
11168
11169
11170 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11171 PyObject *resultobj;
11172 wxFontEncoding arg1 ;
11173 PyObject * obj0 = 0 ;
11174 char *kwnames[] = {
11175 (char *) "encoding", NULL
11176 };
11177
11178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
11179 {
11180 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
11181 if (SWIG_arg_fail(1)) SWIG_fail;
11182 }
11183 {
11184 if (!wxPyCheckForApp()) SWIG_fail;
11185 PyThreadState* __tstate = wxPyBeginAllowThreads();
11186 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
11187
11188 wxPyEndAllowThreads(__tstate);
11189 if (PyErr_Occurred()) SWIG_fail;
11190 }
11191 Py_INCREF(Py_None); resultobj = Py_None;
11192 return resultobj;
11193 fail:
11194 return NULL;
11195 }
11196
11197
11198 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
11199 PyObject *obj;
11200 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11201 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
11202 Py_INCREF(obj);
11203 return Py_BuildValue((char *)"");
11204 }
11205 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
11206 PyObject *resultobj;
11207 wxPyFontEnumerator *result;
11208 char *kwnames[] = {
11209 NULL
11210 };
11211
11212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
11213 {
11214 if (!wxPyCheckForApp()) SWIG_fail;
11215 PyThreadState* __tstate = wxPyBeginAllowThreads();
11216 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
11217
11218 wxPyEndAllowThreads(__tstate);
11219 if (PyErr_Occurred()) SWIG_fail;
11220 }
11221 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
11222 return resultobj;
11223 fail:
11224 return NULL;
11225 }
11226
11227
11228 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
11229 PyObject *resultobj;
11230 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11231 PyObject * obj0 = 0 ;
11232 char *kwnames[] = {
11233 (char *) "self", NULL
11234 };
11235
11236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
11237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11238 if (SWIG_arg_fail(1)) SWIG_fail;
11239 {
11240 PyThreadState* __tstate = wxPyBeginAllowThreads();
11241 delete arg1;
11242
11243 wxPyEndAllowThreads(__tstate);
11244 if (PyErr_Occurred()) SWIG_fail;
11245 }
11246 Py_INCREF(Py_None); resultobj = Py_None;
11247 return resultobj;
11248 fail:
11249 return NULL;
11250 }
11251
11252
11253 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11254 PyObject *resultobj;
11255 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11256 PyObject *arg2 = (PyObject *) 0 ;
11257 PyObject *arg3 = (PyObject *) 0 ;
11258 bool arg4 ;
11259 PyObject * obj0 = 0 ;
11260 PyObject * obj1 = 0 ;
11261 PyObject * obj2 = 0 ;
11262 PyObject * obj3 = 0 ;
11263 char *kwnames[] = {
11264 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11265 };
11266
11267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11269 if (SWIG_arg_fail(1)) SWIG_fail;
11270 arg2 = obj1;
11271 arg3 = obj2;
11272 {
11273 arg4 = (bool)(SWIG_As_bool(obj3));
11274 if (SWIG_arg_fail(4)) SWIG_fail;
11275 }
11276 {
11277 PyThreadState* __tstate = wxPyBeginAllowThreads();
11278 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11279
11280 wxPyEndAllowThreads(__tstate);
11281 if (PyErr_Occurred()) SWIG_fail;
11282 }
11283 Py_INCREF(Py_None); resultobj = Py_None;
11284 return resultobj;
11285 fail:
11286 return NULL;
11287 }
11288
11289
11290 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
11291 PyObject *resultobj;
11292 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11293 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
11294 bool arg3 = (bool) false ;
11295 bool result;
11296 PyObject * obj0 = 0 ;
11297 PyObject * obj1 = 0 ;
11298 PyObject * obj2 = 0 ;
11299 char *kwnames[] = {
11300 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
11301 };
11302
11303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
11304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11305 if (SWIG_arg_fail(1)) SWIG_fail;
11306 if (obj1) {
11307 {
11308 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
11309 if (SWIG_arg_fail(2)) SWIG_fail;
11310 }
11311 }
11312 if (obj2) {
11313 {
11314 arg3 = (bool)(SWIG_As_bool(obj2));
11315 if (SWIG_arg_fail(3)) SWIG_fail;
11316 }
11317 }
11318 {
11319 PyThreadState* __tstate = wxPyBeginAllowThreads();
11320 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
11321
11322 wxPyEndAllowThreads(__tstate);
11323 if (PyErr_Occurred()) SWIG_fail;
11324 }
11325 {
11326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11327 }
11328 return resultobj;
11329 fail:
11330 return NULL;
11331 }
11332
11333
11334 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
11335 PyObject *resultobj;
11336 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11337 wxString const &arg2_defvalue = wxPyEmptyString ;
11338 wxString *arg2 = (wxString *) &arg2_defvalue ;
11339 bool result;
11340 bool temp2 = false ;
11341 PyObject * obj0 = 0 ;
11342 PyObject * obj1 = 0 ;
11343 char *kwnames[] = {
11344 (char *) "self",(char *) "facename", NULL
11345 };
11346
11347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
11348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11349 if (SWIG_arg_fail(1)) SWIG_fail;
11350 if (obj1) {
11351 {
11352 arg2 = wxString_in_helper(obj1);
11353 if (arg2 == NULL) SWIG_fail;
11354 temp2 = true;
11355 }
11356 }
11357 {
11358 PyThreadState* __tstate = wxPyBeginAllowThreads();
11359 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
11360
11361 wxPyEndAllowThreads(__tstate);
11362 if (PyErr_Occurred()) SWIG_fail;
11363 }
11364 {
11365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11366 }
11367 {
11368 if (temp2)
11369 delete arg2;
11370 }
11371 return resultobj;
11372 fail:
11373 {
11374 if (temp2)
11375 delete arg2;
11376 }
11377 return NULL;
11378 }
11379
11380
11381 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
11382 PyObject *resultobj;
11383 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11384 PyObject *result;
11385 PyObject * obj0 = 0 ;
11386 char *kwnames[] = {
11387 (char *) "self", NULL
11388 };
11389
11390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
11391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11392 if (SWIG_arg_fail(1)) SWIG_fail;
11393 {
11394 PyThreadState* __tstate = wxPyBeginAllowThreads();
11395 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
11396
11397 wxPyEndAllowThreads(__tstate);
11398 if (PyErr_Occurred()) SWIG_fail;
11399 }
11400 resultobj = result;
11401 return resultobj;
11402 fail:
11403 return NULL;
11404 }
11405
11406
11407 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
11408 PyObject *resultobj;
11409 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11410 PyObject *result;
11411 PyObject * obj0 = 0 ;
11412 char *kwnames[] = {
11413 (char *) "self", NULL
11414 };
11415
11416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
11417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11418 if (SWIG_arg_fail(1)) SWIG_fail;
11419 {
11420 PyThreadState* __tstate = wxPyBeginAllowThreads();
11421 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
11422
11423 wxPyEndAllowThreads(__tstate);
11424 if (PyErr_Occurred()) SWIG_fail;
11425 }
11426 resultobj = result;
11427 return resultobj;
11428 fail:
11429 return NULL;
11430 }
11431
11432
11433 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
11434 PyObject *obj;
11435 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11436 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
11437 Py_INCREF(obj);
11438 return Py_BuildValue((char *)"");
11439 }
11440 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
11441 PyObject *resultobj;
11442 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11443 int arg2 ;
11444 PyObject * obj0 = 0 ;
11445 PyObject * obj1 = 0 ;
11446 char *kwnames[] = {
11447 (char *) "self",(char *) "Language", NULL
11448 };
11449
11450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
11451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11452 if (SWIG_arg_fail(1)) SWIG_fail;
11453 {
11454 arg2 = (int)(SWIG_As_int(obj1));
11455 if (SWIG_arg_fail(2)) SWIG_fail;
11456 }
11457 if (arg1) (arg1)->Language = arg2;
11458
11459 Py_INCREF(Py_None); resultobj = Py_None;
11460 return resultobj;
11461 fail:
11462 return NULL;
11463 }
11464
11465
11466 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
11467 PyObject *resultobj;
11468 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11469 int result;
11470 PyObject * obj0 = 0 ;
11471 char *kwnames[] = {
11472 (char *) "self", NULL
11473 };
11474
11475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
11476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11477 if (SWIG_arg_fail(1)) SWIG_fail;
11478 result = (int) ((arg1)->Language);
11479
11480 {
11481 resultobj = SWIG_From_int((int)(result));
11482 }
11483 return resultobj;
11484 fail:
11485 return NULL;
11486 }
11487
11488
11489 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
11490 PyObject *resultobj;
11491 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11492 wxString *arg2 = (wxString *) 0 ;
11493 bool temp2 = false ;
11494 PyObject * obj0 = 0 ;
11495 PyObject * obj1 = 0 ;
11496 char *kwnames[] = {
11497 (char *) "self",(char *) "CanonicalName", NULL
11498 };
11499
11500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
11501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11502 if (SWIG_arg_fail(1)) SWIG_fail;
11503 {
11504 arg2 = wxString_in_helper(obj1);
11505 if (arg2 == NULL) SWIG_fail;
11506 temp2 = true;
11507 }
11508 if (arg1) (arg1)->CanonicalName = *arg2;
11509
11510 Py_INCREF(Py_None); resultobj = Py_None;
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_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
11526 PyObject *resultobj;
11527 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11528 wxString *result;
11529 PyObject * obj0 = 0 ;
11530 char *kwnames[] = {
11531 (char *) "self", NULL
11532 };
11533
11534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
11535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11536 if (SWIG_arg_fail(1)) SWIG_fail;
11537 result = (wxString *)& ((arg1)->CanonicalName);
11538
11539 {
11540 #if wxUSE_UNICODE
11541 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11542 #else
11543 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11544 #endif
11545 }
11546 return resultobj;
11547 fail:
11548 return NULL;
11549 }
11550
11551
11552 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
11553 PyObject *resultobj;
11554 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11555 wxString *arg2 = (wxString *) 0 ;
11556 bool temp2 = false ;
11557 PyObject * obj0 = 0 ;
11558 PyObject * obj1 = 0 ;
11559 char *kwnames[] = {
11560 (char *) "self",(char *) "Description", NULL
11561 };
11562
11563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
11564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11565 if (SWIG_arg_fail(1)) SWIG_fail;
11566 {
11567 arg2 = wxString_in_helper(obj1);
11568 if (arg2 == NULL) SWIG_fail;
11569 temp2 = true;
11570 }
11571 if (arg1) (arg1)->Description = *arg2;
11572
11573 Py_INCREF(Py_None); resultobj = Py_None;
11574 {
11575 if (temp2)
11576 delete arg2;
11577 }
11578 return resultobj;
11579 fail:
11580 {
11581 if (temp2)
11582 delete arg2;
11583 }
11584 return NULL;
11585 }
11586
11587
11588 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
11589 PyObject *resultobj;
11590 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11591 wxString *result;
11592 PyObject * obj0 = 0 ;
11593 char *kwnames[] = {
11594 (char *) "self", NULL
11595 };
11596
11597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
11598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11599 if (SWIG_arg_fail(1)) SWIG_fail;
11600 result = (wxString *)& ((arg1)->Description);
11601
11602 {
11603 #if wxUSE_UNICODE
11604 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11605 #else
11606 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11607 #endif
11608 }
11609 return resultobj;
11610 fail:
11611 return NULL;
11612 }
11613
11614
11615 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
11616 PyObject *obj;
11617 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11618 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
11619 Py_INCREF(obj);
11620 return Py_BuildValue((char *)"");
11621 }
11622 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11623 PyObject *resultobj;
11624 int arg1 = (int) -1 ;
11625 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11626 wxLocale *result;
11627 PyObject * obj0 = 0 ;
11628 PyObject * obj1 = 0 ;
11629 char *kwnames[] = {
11630 (char *) "language",(char *) "flags", NULL
11631 };
11632
11633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
11634 if (obj0) {
11635 {
11636 arg1 = (int)(SWIG_As_int(obj0));
11637 if (SWIG_arg_fail(1)) SWIG_fail;
11638 }
11639 }
11640 if (obj1) {
11641 {
11642 arg2 = (int)(SWIG_As_int(obj1));
11643 if (SWIG_arg_fail(2)) SWIG_fail;
11644 }
11645 }
11646 {
11647 PyThreadState* __tstate = wxPyBeginAllowThreads();
11648 result = (wxLocale *)new_wxLocale(arg1,arg2);
11649
11650 wxPyEndAllowThreads(__tstate);
11651 if (PyErr_Occurred()) SWIG_fail;
11652 }
11653 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11654 return resultobj;
11655 fail:
11656 return NULL;
11657 }
11658
11659
11660 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11661 PyObject *resultobj;
11662 wxLocale *arg1 = (wxLocale *) 0 ;
11663 PyObject * obj0 = 0 ;
11664 char *kwnames[] = {
11665 (char *) "self", NULL
11666 };
11667
11668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11670 if (SWIG_arg_fail(1)) SWIG_fail;
11671 {
11672 PyThreadState* __tstate = wxPyBeginAllowThreads();
11673 delete arg1;
11674
11675 wxPyEndAllowThreads(__tstate);
11676 if (PyErr_Occurred()) SWIG_fail;
11677 }
11678 Py_INCREF(Py_None); resultobj = Py_None;
11679 return resultobj;
11680 fail:
11681 return NULL;
11682 }
11683
11684
11685 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11686 PyObject *resultobj;
11687 wxLocale *arg1 = (wxLocale *) 0 ;
11688 wxString *arg2 = 0 ;
11689 wxString const &arg3_defvalue = wxPyEmptyString ;
11690 wxString *arg3 = (wxString *) &arg3_defvalue ;
11691 wxString const &arg4_defvalue = wxPyEmptyString ;
11692 wxString *arg4 = (wxString *) &arg4_defvalue ;
11693 bool arg5 = (bool) true ;
11694 bool arg6 = (bool) false ;
11695 bool result;
11696 bool temp2 = false ;
11697 bool temp3 = false ;
11698 bool temp4 = false ;
11699 PyObject * obj0 = 0 ;
11700 PyObject * obj1 = 0 ;
11701 PyObject * obj2 = 0 ;
11702 PyObject * obj3 = 0 ;
11703 PyObject * obj4 = 0 ;
11704 PyObject * obj5 = 0 ;
11705 char *kwnames[] = {
11706 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11707 };
11708
11709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11711 if (SWIG_arg_fail(1)) SWIG_fail;
11712 {
11713 arg2 = wxString_in_helper(obj1);
11714 if (arg2 == NULL) SWIG_fail;
11715 temp2 = true;
11716 }
11717 if (obj2) {
11718 {
11719 arg3 = wxString_in_helper(obj2);
11720 if (arg3 == NULL) SWIG_fail;
11721 temp3 = true;
11722 }
11723 }
11724 if (obj3) {
11725 {
11726 arg4 = wxString_in_helper(obj3);
11727 if (arg4 == NULL) SWIG_fail;
11728 temp4 = true;
11729 }
11730 }
11731 if (obj4) {
11732 {
11733 arg5 = (bool)(SWIG_As_bool(obj4));
11734 if (SWIG_arg_fail(5)) SWIG_fail;
11735 }
11736 }
11737 if (obj5) {
11738 {
11739 arg6 = (bool)(SWIG_As_bool(obj5));
11740 if (SWIG_arg_fail(6)) SWIG_fail;
11741 }
11742 }
11743 {
11744 PyThreadState* __tstate = wxPyBeginAllowThreads();
11745 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11746
11747 wxPyEndAllowThreads(__tstate);
11748 if (PyErr_Occurred()) SWIG_fail;
11749 }
11750 {
11751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11752 }
11753 {
11754 if (temp2)
11755 delete arg2;
11756 }
11757 {
11758 if (temp3)
11759 delete arg3;
11760 }
11761 {
11762 if (temp4)
11763 delete arg4;
11764 }
11765 return resultobj;
11766 fail:
11767 {
11768 if (temp2)
11769 delete arg2;
11770 }
11771 {
11772 if (temp3)
11773 delete arg3;
11774 }
11775 {
11776 if (temp4)
11777 delete arg4;
11778 }
11779 return NULL;
11780 }
11781
11782
11783 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11784 PyObject *resultobj;
11785 wxLocale *arg1 = (wxLocale *) 0 ;
11786 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11787 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11788 bool result;
11789 PyObject * obj0 = 0 ;
11790 PyObject * obj1 = 0 ;
11791 PyObject * obj2 = 0 ;
11792 char *kwnames[] = {
11793 (char *) "self",(char *) "language",(char *) "flags", NULL
11794 };
11795
11796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11798 if (SWIG_arg_fail(1)) SWIG_fail;
11799 if (obj1) {
11800 {
11801 arg2 = (int)(SWIG_As_int(obj1));
11802 if (SWIG_arg_fail(2)) SWIG_fail;
11803 }
11804 }
11805 if (obj2) {
11806 {
11807 arg3 = (int)(SWIG_As_int(obj2));
11808 if (SWIG_arg_fail(3)) SWIG_fail;
11809 }
11810 }
11811 {
11812 PyThreadState* __tstate = wxPyBeginAllowThreads();
11813 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11814
11815 wxPyEndAllowThreads(__tstate);
11816 if (PyErr_Occurred()) SWIG_fail;
11817 }
11818 {
11819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11820 }
11821 return resultobj;
11822 fail:
11823 return NULL;
11824 }
11825
11826
11827 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11828 PyObject *resultobj;
11829 int result;
11830 char *kwnames[] = {
11831 NULL
11832 };
11833
11834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11835 {
11836 PyThreadState* __tstate = wxPyBeginAllowThreads();
11837 result = (int)wxLocale::GetSystemLanguage();
11838
11839 wxPyEndAllowThreads(__tstate);
11840 if (PyErr_Occurred()) SWIG_fail;
11841 }
11842 {
11843 resultobj = SWIG_From_int((int)(result));
11844 }
11845 return resultobj;
11846 fail:
11847 return NULL;
11848 }
11849
11850
11851 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11852 PyObject *resultobj;
11853 wxFontEncoding result;
11854 char *kwnames[] = {
11855 NULL
11856 };
11857
11858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11859 {
11860 PyThreadState* __tstate = wxPyBeginAllowThreads();
11861 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11862
11863 wxPyEndAllowThreads(__tstate);
11864 if (PyErr_Occurred()) SWIG_fail;
11865 }
11866 resultobj = SWIG_From_int((result));
11867 return resultobj;
11868 fail:
11869 return NULL;
11870 }
11871
11872
11873 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11874 PyObject *resultobj;
11875 wxString result;
11876 char *kwnames[] = {
11877 NULL
11878 };
11879
11880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11881 {
11882 PyThreadState* __tstate = wxPyBeginAllowThreads();
11883 result = wxLocale::GetSystemEncodingName();
11884
11885 wxPyEndAllowThreads(__tstate);
11886 if (PyErr_Occurred()) SWIG_fail;
11887 }
11888 {
11889 #if wxUSE_UNICODE
11890 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11891 #else
11892 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11893 #endif
11894 }
11895 return resultobj;
11896 fail:
11897 return NULL;
11898 }
11899
11900
11901 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11902 PyObject *resultobj;
11903 wxLocale *arg1 = (wxLocale *) 0 ;
11904 bool result;
11905 PyObject * obj0 = 0 ;
11906 char *kwnames[] = {
11907 (char *) "self", NULL
11908 };
11909
11910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11912 if (SWIG_arg_fail(1)) SWIG_fail;
11913 {
11914 PyThreadState* __tstate = wxPyBeginAllowThreads();
11915 result = (bool)((wxLocale const *)arg1)->IsOk();
11916
11917 wxPyEndAllowThreads(__tstate);
11918 if (PyErr_Occurred()) SWIG_fail;
11919 }
11920 {
11921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11922 }
11923 return resultobj;
11924 fail:
11925 return NULL;
11926 }
11927
11928
11929 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11930 PyObject *resultobj;
11931 wxLocale *arg1 = (wxLocale *) 0 ;
11932 wxString result;
11933 PyObject * obj0 = 0 ;
11934 char *kwnames[] = {
11935 (char *) "self", NULL
11936 };
11937
11938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11940 if (SWIG_arg_fail(1)) SWIG_fail;
11941 {
11942 PyThreadState* __tstate = wxPyBeginAllowThreads();
11943 result = ((wxLocale const *)arg1)->GetLocale();
11944
11945 wxPyEndAllowThreads(__tstate);
11946 if (PyErr_Occurred()) SWIG_fail;
11947 }
11948 {
11949 #if wxUSE_UNICODE
11950 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11951 #else
11952 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11953 #endif
11954 }
11955 return resultobj;
11956 fail:
11957 return NULL;
11958 }
11959
11960
11961 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11962 PyObject *resultobj;
11963 wxLocale *arg1 = (wxLocale *) 0 ;
11964 int result;
11965 PyObject * obj0 = 0 ;
11966 char *kwnames[] = {
11967 (char *) "self", NULL
11968 };
11969
11970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
11971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11972 if (SWIG_arg_fail(1)) SWIG_fail;
11973 {
11974 PyThreadState* __tstate = wxPyBeginAllowThreads();
11975 result = (int)((wxLocale const *)arg1)->GetLanguage();
11976
11977 wxPyEndAllowThreads(__tstate);
11978 if (PyErr_Occurred()) SWIG_fail;
11979 }
11980 {
11981 resultobj = SWIG_From_int((int)(result));
11982 }
11983 return resultobj;
11984 fail:
11985 return NULL;
11986 }
11987
11988
11989 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
11990 PyObject *resultobj;
11991 wxLocale *arg1 = (wxLocale *) 0 ;
11992 wxString result;
11993 PyObject * obj0 = 0 ;
11994 char *kwnames[] = {
11995 (char *) "self", NULL
11996 };
11997
11998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
11999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12000 if (SWIG_arg_fail(1)) SWIG_fail;
12001 {
12002 PyThreadState* __tstate = wxPyBeginAllowThreads();
12003 result = ((wxLocale const *)arg1)->GetSysName();
12004
12005 wxPyEndAllowThreads(__tstate);
12006 if (PyErr_Occurred()) SWIG_fail;
12007 }
12008 {
12009 #if wxUSE_UNICODE
12010 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12011 #else
12012 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12013 #endif
12014 }
12015 return resultobj;
12016 fail:
12017 return NULL;
12018 }
12019
12020
12021 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
12022 PyObject *resultobj;
12023 wxLocale *arg1 = (wxLocale *) 0 ;
12024 wxString result;
12025 PyObject * obj0 = 0 ;
12026 char *kwnames[] = {
12027 (char *) "self", NULL
12028 };
12029
12030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
12031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12032 if (SWIG_arg_fail(1)) SWIG_fail;
12033 {
12034 PyThreadState* __tstate = wxPyBeginAllowThreads();
12035 result = ((wxLocale const *)arg1)->GetCanonicalName();
12036
12037 wxPyEndAllowThreads(__tstate);
12038 if (PyErr_Occurred()) SWIG_fail;
12039 }
12040 {
12041 #if wxUSE_UNICODE
12042 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12043 #else
12044 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12045 #endif
12046 }
12047 return resultobj;
12048 fail:
12049 return NULL;
12050 }
12051
12052
12053 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
12054 PyObject *resultobj;
12055 wxString *arg1 = 0 ;
12056 bool temp1 = false ;
12057 PyObject * obj0 = 0 ;
12058 char *kwnames[] = {
12059 (char *) "prefix", NULL
12060 };
12061
12062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
12063 {
12064 arg1 = wxString_in_helper(obj0);
12065 if (arg1 == NULL) SWIG_fail;
12066 temp1 = true;
12067 }
12068 {
12069 PyThreadState* __tstate = wxPyBeginAllowThreads();
12070 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
12071
12072 wxPyEndAllowThreads(__tstate);
12073 if (PyErr_Occurred()) SWIG_fail;
12074 }
12075 Py_INCREF(Py_None); resultobj = Py_None;
12076 {
12077 if (temp1)
12078 delete arg1;
12079 }
12080 return resultobj;
12081 fail:
12082 {
12083 if (temp1)
12084 delete arg1;
12085 }
12086 return NULL;
12087 }
12088
12089
12090 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
12091 PyObject *resultobj;
12092 wxLocale *arg1 = (wxLocale *) 0 ;
12093 wxString *arg2 = 0 ;
12094 bool result;
12095 bool temp2 = false ;
12096 PyObject * obj0 = 0 ;
12097 PyObject * obj1 = 0 ;
12098 char *kwnames[] = {
12099 (char *) "self",(char *) "szDomain", NULL
12100 };
12101
12102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
12103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12104 if (SWIG_arg_fail(1)) SWIG_fail;
12105 {
12106 arg2 = wxString_in_helper(obj1);
12107 if (arg2 == NULL) SWIG_fail;
12108 temp2 = true;
12109 }
12110 {
12111 PyThreadState* __tstate = wxPyBeginAllowThreads();
12112 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
12113
12114 wxPyEndAllowThreads(__tstate);
12115 if (PyErr_Occurred()) SWIG_fail;
12116 }
12117 {
12118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12119 }
12120 {
12121 if (temp2)
12122 delete arg2;
12123 }
12124 return resultobj;
12125 fail:
12126 {
12127 if (temp2)
12128 delete arg2;
12129 }
12130 return NULL;
12131 }
12132
12133
12134 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
12135 PyObject *resultobj;
12136 wxLocale *arg1 = (wxLocale *) 0 ;
12137 wxString *arg2 = 0 ;
12138 bool result;
12139 bool temp2 = false ;
12140 PyObject * obj0 = 0 ;
12141 PyObject * obj1 = 0 ;
12142 char *kwnames[] = {
12143 (char *) "self",(char *) "szDomain", NULL
12144 };
12145
12146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
12147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12148 if (SWIG_arg_fail(1)) SWIG_fail;
12149 {
12150 arg2 = wxString_in_helper(obj1);
12151 if (arg2 == NULL) SWIG_fail;
12152 temp2 = true;
12153 }
12154 {
12155 PyThreadState* __tstate = wxPyBeginAllowThreads();
12156 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
12157
12158 wxPyEndAllowThreads(__tstate);
12159 if (PyErr_Occurred()) SWIG_fail;
12160 }
12161 {
12162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12163 }
12164 {
12165 if (temp2)
12166 delete arg2;
12167 }
12168 return resultobj;
12169 fail:
12170 {
12171 if (temp2)
12172 delete arg2;
12173 }
12174 return NULL;
12175 }
12176
12177
12178 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12179 PyObject *resultobj;
12180 int arg1 ;
12181 wxLanguageInfo *result;
12182 PyObject * obj0 = 0 ;
12183 char *kwnames[] = {
12184 (char *) "lang", NULL
12185 };
12186
12187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
12188 {
12189 arg1 = (int)(SWIG_As_int(obj0));
12190 if (SWIG_arg_fail(1)) SWIG_fail;
12191 }
12192 {
12193 PyThreadState* __tstate = wxPyBeginAllowThreads();
12194 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
12195
12196 wxPyEndAllowThreads(__tstate);
12197 if (PyErr_Occurred()) SWIG_fail;
12198 }
12199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
12200 return resultobj;
12201 fail:
12202 return NULL;
12203 }
12204
12205
12206 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
12207 PyObject *resultobj;
12208 int arg1 ;
12209 wxString result;
12210 PyObject * obj0 = 0 ;
12211 char *kwnames[] = {
12212 (char *) "lang", NULL
12213 };
12214
12215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
12216 {
12217 arg1 = (int)(SWIG_As_int(obj0));
12218 if (SWIG_arg_fail(1)) SWIG_fail;
12219 }
12220 {
12221 PyThreadState* __tstate = wxPyBeginAllowThreads();
12222 result = wxLocale::GetLanguageName(arg1);
12223
12224 wxPyEndAllowThreads(__tstate);
12225 if (PyErr_Occurred()) SWIG_fail;
12226 }
12227 {
12228 #if wxUSE_UNICODE
12229 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12230 #else
12231 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12232 #endif
12233 }
12234 return resultobj;
12235 fail:
12236 return NULL;
12237 }
12238
12239
12240 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12241 PyObject *resultobj;
12242 wxString *arg1 = 0 ;
12243 wxLanguageInfo *result;
12244 bool temp1 = false ;
12245 PyObject * obj0 = 0 ;
12246 char *kwnames[] = {
12247 (char *) "locale", NULL
12248 };
12249
12250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
12251 {
12252 arg1 = wxString_in_helper(obj0);
12253 if (arg1 == NULL) SWIG_fail;
12254 temp1 = true;
12255 }
12256 {
12257 PyThreadState* __tstate = wxPyBeginAllowThreads();
12258 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
12259
12260 wxPyEndAllowThreads(__tstate);
12261 if (PyErr_Occurred()) SWIG_fail;
12262 }
12263 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
12264 {
12265 if (temp1)
12266 delete arg1;
12267 }
12268 return resultobj;
12269 fail:
12270 {
12271 if (temp1)
12272 delete arg1;
12273 }
12274 return NULL;
12275 }
12276
12277
12278 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
12279 PyObject *resultobj;
12280 wxLanguageInfo *arg1 = 0 ;
12281 PyObject * obj0 = 0 ;
12282 char *kwnames[] = {
12283 (char *) "info", NULL
12284 };
12285
12286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
12287 {
12288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
12289 if (SWIG_arg_fail(1)) SWIG_fail;
12290 if (arg1 == NULL) {
12291 SWIG_null_ref("wxLanguageInfo");
12292 }
12293 if (SWIG_arg_fail(1)) SWIG_fail;
12294 }
12295 {
12296 PyThreadState* __tstate = wxPyBeginAllowThreads();
12297 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
12298
12299 wxPyEndAllowThreads(__tstate);
12300 if (PyErr_Occurred()) SWIG_fail;
12301 }
12302 Py_INCREF(Py_None); resultobj = Py_None;
12303 return resultobj;
12304 fail:
12305 return NULL;
12306 }
12307
12308
12309 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
12310 PyObject *resultobj;
12311 wxLocale *arg1 = (wxLocale *) 0 ;
12312 wxString *arg2 = 0 ;
12313 wxString const &arg3_defvalue = wxPyEmptyString ;
12314 wxString *arg3 = (wxString *) &arg3_defvalue ;
12315 wxString result;
12316 bool temp2 = false ;
12317 bool temp3 = false ;
12318 PyObject * obj0 = 0 ;
12319 PyObject * obj1 = 0 ;
12320 PyObject * obj2 = 0 ;
12321 char *kwnames[] = {
12322 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
12323 };
12324
12325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
12326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12327 if (SWIG_arg_fail(1)) SWIG_fail;
12328 {
12329 arg2 = wxString_in_helper(obj1);
12330 if (arg2 == NULL) SWIG_fail;
12331 temp2 = true;
12332 }
12333 if (obj2) {
12334 {
12335 arg3 = wxString_in_helper(obj2);
12336 if (arg3 == NULL) SWIG_fail;
12337 temp3 = true;
12338 }
12339 }
12340 {
12341 PyThreadState* __tstate = wxPyBeginAllowThreads();
12342 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
12343
12344 wxPyEndAllowThreads(__tstate);
12345 if (PyErr_Occurred()) SWIG_fail;
12346 }
12347 {
12348 #if wxUSE_UNICODE
12349 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12350 #else
12351 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12352 #endif
12353 }
12354 {
12355 if (temp2)
12356 delete arg2;
12357 }
12358 {
12359 if (temp3)
12360 delete arg3;
12361 }
12362 return resultobj;
12363 fail:
12364 {
12365 if (temp2)
12366 delete arg2;
12367 }
12368 {
12369 if (temp3)
12370 delete arg3;
12371 }
12372 return NULL;
12373 }
12374
12375
12376 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
12377 PyObject *resultobj;
12378 wxLocale *arg1 = (wxLocale *) 0 ;
12379 wxString *result;
12380 PyObject * obj0 = 0 ;
12381 char *kwnames[] = {
12382 (char *) "self", NULL
12383 };
12384
12385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
12386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12387 if (SWIG_arg_fail(1)) SWIG_fail;
12388 {
12389 PyThreadState* __tstate = wxPyBeginAllowThreads();
12390 {
12391 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
12392 result = (wxString *) &_result_ref;
12393 }
12394
12395 wxPyEndAllowThreads(__tstate);
12396 if (PyErr_Occurred()) SWIG_fail;
12397 }
12398 {
12399 #if wxUSE_UNICODE
12400 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12401 #else
12402 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12403 #endif
12404 }
12405 return resultobj;
12406 fail:
12407 return NULL;
12408 }
12409
12410
12411 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
12412 PyObject *obj;
12413 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12414 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
12415 Py_INCREF(obj);
12416 return Py_BuildValue((char *)"");
12417 }
12418 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
12419 PyObject *resultobj;
12420 wxLocale *result;
12421 char *kwnames[] = {
12422 NULL
12423 };
12424
12425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
12426 {
12427 PyThreadState* __tstate = wxPyBeginAllowThreads();
12428 result = (wxLocale *)wxGetLocale();
12429
12430 wxPyEndAllowThreads(__tstate);
12431 if (PyErr_Occurred()) SWIG_fail;
12432 }
12433 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
12434 return resultobj;
12435 fail:
12436 return NULL;
12437 }
12438
12439
12440 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
12441 PyObject *resultobj;
12442 wxString *arg1 = 0 ;
12443 wxString result;
12444 bool temp1 = false ;
12445 PyObject * obj0 = 0 ;
12446
12447 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
12448 {
12449 arg1 = wxString_in_helper(obj0);
12450 if (arg1 == NULL) SWIG_fail;
12451 temp1 = true;
12452 }
12453 {
12454 PyThreadState* __tstate = wxPyBeginAllowThreads();
12455 result = wxGetTranslation((wxString const &)*arg1);
12456
12457 wxPyEndAllowThreads(__tstate);
12458 if (PyErr_Occurred()) SWIG_fail;
12459 }
12460 {
12461 #if wxUSE_UNICODE
12462 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12463 #else
12464 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12465 #endif
12466 }
12467 {
12468 if (temp1)
12469 delete arg1;
12470 }
12471 return resultobj;
12472 fail:
12473 {
12474 if (temp1)
12475 delete arg1;
12476 }
12477 return NULL;
12478 }
12479
12480
12481 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
12482 PyObject *resultobj;
12483 wxString *arg1 = 0 ;
12484 wxString *arg2 = 0 ;
12485 size_t arg3 ;
12486 wxString result;
12487 bool temp1 = false ;
12488 bool temp2 = false ;
12489 PyObject * obj0 = 0 ;
12490 PyObject * obj1 = 0 ;
12491 PyObject * obj2 = 0 ;
12492
12493 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
12494 {
12495 arg1 = wxString_in_helper(obj0);
12496 if (arg1 == NULL) SWIG_fail;
12497 temp1 = true;
12498 }
12499 {
12500 arg2 = wxString_in_helper(obj1);
12501 if (arg2 == NULL) SWIG_fail;
12502 temp2 = true;
12503 }
12504 {
12505 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
12506 if (SWIG_arg_fail(3)) SWIG_fail;
12507 }
12508 {
12509 PyThreadState* __tstate = wxPyBeginAllowThreads();
12510 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12511
12512 wxPyEndAllowThreads(__tstate);
12513 if (PyErr_Occurred()) SWIG_fail;
12514 }
12515 {
12516 #if wxUSE_UNICODE
12517 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12518 #else
12519 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12520 #endif
12521 }
12522 {
12523 if (temp1)
12524 delete arg1;
12525 }
12526 {
12527 if (temp2)
12528 delete arg2;
12529 }
12530 return resultobj;
12531 fail:
12532 {
12533 if (temp1)
12534 delete arg1;
12535 }
12536 {
12537 if (temp2)
12538 delete arg2;
12539 }
12540 return NULL;
12541 }
12542
12543
12544 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
12545 int argc;
12546 PyObject *argv[4];
12547 int ii;
12548
12549 argc = PyObject_Length(args);
12550 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
12551 argv[ii] = PyTuple_GetItem(args,ii);
12552 }
12553 if (argc == 1) {
12554 int _v;
12555 {
12556 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12557 }
12558 if (_v) {
12559 return _wrap_GetTranslation__SWIG_0(self,args);
12560 }
12561 }
12562 if (argc == 3) {
12563 int _v;
12564 {
12565 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12566 }
12567 if (_v) {
12568 {
12569 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
12570 }
12571 if (_v) {
12572 _v = SWIG_Check_unsigned_SS_long(argv[2]);
12573 if (_v) {
12574 return _wrap_GetTranslation__SWIG_1(self,args);
12575 }
12576 }
12577 }
12578 }
12579
12580 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
12581 return NULL;
12582 }
12583
12584
12585 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12586 PyObject *resultobj;
12587 wxEncodingConverter *result;
12588 char *kwnames[] = {
12589 NULL
12590 };
12591
12592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
12593 {
12594 PyThreadState* __tstate = wxPyBeginAllowThreads();
12595 result = (wxEncodingConverter *)new wxEncodingConverter();
12596
12597 wxPyEndAllowThreads(__tstate);
12598 if (PyErr_Occurred()) SWIG_fail;
12599 }
12600 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
12601 return resultobj;
12602 fail:
12603 return NULL;
12604 }
12605
12606
12607 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12608 PyObject *resultobj;
12609 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12610 PyObject * obj0 = 0 ;
12611 char *kwnames[] = {
12612 (char *) "self", NULL
12613 };
12614
12615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
12616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12617 if (SWIG_arg_fail(1)) SWIG_fail;
12618 {
12619 PyThreadState* __tstate = wxPyBeginAllowThreads();
12620 delete arg1;
12621
12622 wxPyEndAllowThreads(__tstate);
12623 if (PyErr_Occurred()) SWIG_fail;
12624 }
12625 Py_INCREF(Py_None); resultobj = Py_None;
12626 return resultobj;
12627 fail:
12628 return NULL;
12629 }
12630
12631
12632 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
12633 PyObject *resultobj;
12634 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12635 wxFontEncoding arg2 ;
12636 wxFontEncoding arg3 ;
12637 int arg4 = (int) wxCONVERT_STRICT ;
12638 bool result;
12639 PyObject * obj0 = 0 ;
12640 PyObject * obj1 = 0 ;
12641 PyObject * obj2 = 0 ;
12642 PyObject * obj3 = 0 ;
12643 char *kwnames[] = {
12644 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
12645 };
12646
12647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12649 if (SWIG_arg_fail(1)) SWIG_fail;
12650 {
12651 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12652 if (SWIG_arg_fail(2)) SWIG_fail;
12653 }
12654 {
12655 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12656 if (SWIG_arg_fail(3)) SWIG_fail;
12657 }
12658 if (obj3) {
12659 {
12660 arg4 = (int)(SWIG_As_int(obj3));
12661 if (SWIG_arg_fail(4)) SWIG_fail;
12662 }
12663 }
12664 {
12665 PyThreadState* __tstate = wxPyBeginAllowThreads();
12666 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12667
12668 wxPyEndAllowThreads(__tstate);
12669 if (PyErr_Occurred()) SWIG_fail;
12670 }
12671 {
12672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12673 }
12674 return resultobj;
12675 fail:
12676 return NULL;
12677 }
12678
12679
12680 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12681 PyObject *resultobj;
12682 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12683 wxString *arg2 = 0 ;
12684 wxString result;
12685 bool temp2 = false ;
12686 PyObject * obj0 = 0 ;
12687 PyObject * obj1 = 0 ;
12688 char *kwnames[] = {
12689 (char *) "self",(char *) "input", NULL
12690 };
12691
12692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12694 if (SWIG_arg_fail(1)) SWIG_fail;
12695 {
12696 arg2 = wxString_in_helper(obj1);
12697 if (arg2 == NULL) SWIG_fail;
12698 temp2 = true;
12699 }
12700 {
12701 PyThreadState* __tstate = wxPyBeginAllowThreads();
12702 result = (arg1)->Convert((wxString const &)*arg2);
12703
12704 wxPyEndAllowThreads(__tstate);
12705 if (PyErr_Occurred()) SWIG_fail;
12706 }
12707 {
12708 #if wxUSE_UNICODE
12709 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12710 #else
12711 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12712 #endif
12713 }
12714 {
12715 if (temp2)
12716 delete arg2;
12717 }
12718 return resultobj;
12719 fail:
12720 {
12721 if (temp2)
12722 delete arg2;
12723 }
12724 return NULL;
12725 }
12726
12727
12728 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12729 PyObject *resultobj;
12730 wxFontEncoding arg1 ;
12731 int arg2 = (int) wxPLATFORM_CURRENT ;
12732 wxFontEncodingArray result;
12733 PyObject * obj0 = 0 ;
12734 PyObject * obj1 = 0 ;
12735 char *kwnames[] = {
12736 (char *) "enc",(char *) "platform", NULL
12737 };
12738
12739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12740 {
12741 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12742 if (SWIG_arg_fail(1)) SWIG_fail;
12743 }
12744 if (obj1) {
12745 {
12746 arg2 = (int)(SWIG_As_int(obj1));
12747 if (SWIG_arg_fail(2)) SWIG_fail;
12748 }
12749 }
12750 {
12751 PyThreadState* __tstate = wxPyBeginAllowThreads();
12752 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12753
12754 wxPyEndAllowThreads(__tstate);
12755 if (PyErr_Occurred()) SWIG_fail;
12756 }
12757 {
12758 resultobj = PyList_New(0);
12759 for (size_t i=0; i < (&result)->GetCount(); i++) {
12760 PyObject* number = PyInt_FromLong((&result)->Item(i));
12761 PyList_Append(resultobj, number);
12762 Py_DECREF(number);
12763 }
12764 }
12765 return resultobj;
12766 fail:
12767 return NULL;
12768 }
12769
12770
12771 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12772 PyObject *resultobj;
12773 wxFontEncoding arg1 ;
12774 wxFontEncodingArray result;
12775 PyObject * obj0 = 0 ;
12776 char *kwnames[] = {
12777 (char *) "enc", NULL
12778 };
12779
12780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12781 {
12782 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12783 if (SWIG_arg_fail(1)) SWIG_fail;
12784 }
12785 {
12786 PyThreadState* __tstate = wxPyBeginAllowThreads();
12787 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12788
12789 wxPyEndAllowThreads(__tstate);
12790 if (PyErr_Occurred()) SWIG_fail;
12791 }
12792 {
12793 resultobj = PyList_New(0);
12794 for (size_t i=0; i < (&result)->GetCount(); i++) {
12795 PyObject* number = PyInt_FromLong((&result)->Item(i));
12796 PyList_Append(resultobj, number);
12797 Py_DECREF(number);
12798 }
12799 }
12800 return resultobj;
12801 fail:
12802 return NULL;
12803 }
12804
12805
12806 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12807 PyObject *resultobj;
12808 wxFontEncoding arg1 ;
12809 wxFontEncoding arg2 ;
12810 bool result;
12811 PyObject * obj0 = 0 ;
12812 PyObject * obj1 = 0 ;
12813 char *kwnames[] = {
12814 (char *) "encIn",(char *) "encOut", NULL
12815 };
12816
12817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12818 {
12819 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12820 if (SWIG_arg_fail(1)) SWIG_fail;
12821 }
12822 {
12823 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12824 if (SWIG_arg_fail(2)) SWIG_fail;
12825 }
12826 {
12827 PyThreadState* __tstate = wxPyBeginAllowThreads();
12828 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12829
12830 wxPyEndAllowThreads(__tstate);
12831 if (PyErr_Occurred()) SWIG_fail;
12832 }
12833 {
12834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12835 }
12836 return resultobj;
12837 fail:
12838 return NULL;
12839 }
12840
12841
12842 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12843 PyObject *obj;
12844 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12845 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12846 Py_INCREF(obj);
12847 return Py_BuildValue((char *)"");
12848 }
12849 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12850 PyObject *resultobj;
12851 wxDC *arg1 = (wxDC *) 0 ;
12852 PyObject * obj0 = 0 ;
12853 char *kwnames[] = {
12854 (char *) "self", NULL
12855 };
12856
12857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12859 if (SWIG_arg_fail(1)) SWIG_fail;
12860 {
12861 PyThreadState* __tstate = wxPyBeginAllowThreads();
12862 delete arg1;
12863
12864 wxPyEndAllowThreads(__tstate);
12865 if (PyErr_Occurred()) SWIG_fail;
12866 }
12867 Py_INCREF(Py_None); resultobj = Py_None;
12868 return resultobj;
12869 fail:
12870 return NULL;
12871 }
12872
12873
12874 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12875 PyObject *resultobj;
12876 wxDC *arg1 = (wxDC *) 0 ;
12877 PyObject * obj0 = 0 ;
12878 char *kwnames[] = {
12879 (char *) "self", NULL
12880 };
12881
12882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12884 if (SWIG_arg_fail(1)) SWIG_fail;
12885 {
12886 PyThreadState* __tstate = wxPyBeginAllowThreads();
12887 (arg1)->BeginDrawing();
12888
12889 wxPyEndAllowThreads(__tstate);
12890 if (PyErr_Occurred()) SWIG_fail;
12891 }
12892 Py_INCREF(Py_None); resultobj = Py_None;
12893 return resultobj;
12894 fail:
12895 return NULL;
12896 }
12897
12898
12899 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12900 PyObject *resultobj;
12901 wxDC *arg1 = (wxDC *) 0 ;
12902 PyObject * obj0 = 0 ;
12903 char *kwnames[] = {
12904 (char *) "self", NULL
12905 };
12906
12907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12909 if (SWIG_arg_fail(1)) SWIG_fail;
12910 {
12911 PyThreadState* __tstate = wxPyBeginAllowThreads();
12912 (arg1)->EndDrawing();
12913
12914 wxPyEndAllowThreads(__tstate);
12915 if (PyErr_Occurred()) SWIG_fail;
12916 }
12917 Py_INCREF(Py_None); resultobj = Py_None;
12918 return resultobj;
12919 fail:
12920 return NULL;
12921 }
12922
12923
12924 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12925 PyObject *resultobj;
12926 wxDC *arg1 = (wxDC *) 0 ;
12927 int arg2 ;
12928 int arg3 ;
12929 wxColour *arg4 = 0 ;
12930 int arg5 = (int) wxFLOOD_SURFACE ;
12931 bool result;
12932 wxColour temp4 ;
12933 PyObject * obj0 = 0 ;
12934 PyObject * obj1 = 0 ;
12935 PyObject * obj2 = 0 ;
12936 PyObject * obj3 = 0 ;
12937 PyObject * obj4 = 0 ;
12938 char *kwnames[] = {
12939 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12940 };
12941
12942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12944 if (SWIG_arg_fail(1)) SWIG_fail;
12945 {
12946 arg2 = (int)(SWIG_As_int(obj1));
12947 if (SWIG_arg_fail(2)) SWIG_fail;
12948 }
12949 {
12950 arg3 = (int)(SWIG_As_int(obj2));
12951 if (SWIG_arg_fail(3)) SWIG_fail;
12952 }
12953 {
12954 arg4 = &temp4;
12955 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12956 }
12957 if (obj4) {
12958 {
12959 arg5 = (int)(SWIG_As_int(obj4));
12960 if (SWIG_arg_fail(5)) SWIG_fail;
12961 }
12962 }
12963 {
12964 PyThreadState* __tstate = wxPyBeginAllowThreads();
12965 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
12966
12967 wxPyEndAllowThreads(__tstate);
12968 if (PyErr_Occurred()) SWIG_fail;
12969 }
12970 {
12971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12972 }
12973 return resultobj;
12974 fail:
12975 return NULL;
12976 }
12977
12978
12979 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12980 PyObject *resultobj;
12981 wxDC *arg1 = (wxDC *) 0 ;
12982 wxPoint *arg2 = 0 ;
12983 wxColour *arg3 = 0 ;
12984 int arg4 = (int) wxFLOOD_SURFACE ;
12985 bool result;
12986 wxPoint temp2 ;
12987 wxColour temp3 ;
12988 PyObject * obj0 = 0 ;
12989 PyObject * obj1 = 0 ;
12990 PyObject * obj2 = 0 ;
12991 PyObject * obj3 = 0 ;
12992 char *kwnames[] = {
12993 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
12994 };
12995
12996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12998 if (SWIG_arg_fail(1)) SWIG_fail;
12999 {
13000 arg2 = &temp2;
13001 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13002 }
13003 {
13004 arg3 = &temp3;
13005 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
13006 }
13007 if (obj3) {
13008 {
13009 arg4 = (int)(SWIG_As_int(obj3));
13010 if (SWIG_arg_fail(4)) SWIG_fail;
13011 }
13012 }
13013 {
13014 PyThreadState* __tstate = wxPyBeginAllowThreads();
13015 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
13016
13017 wxPyEndAllowThreads(__tstate);
13018 if (PyErr_Occurred()) SWIG_fail;
13019 }
13020 {
13021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13022 }
13023 return resultobj;
13024 fail:
13025 return NULL;
13026 }
13027
13028
13029 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
13030 PyObject *resultobj;
13031 wxDC *arg1 = (wxDC *) 0 ;
13032 int arg2 ;
13033 int arg3 ;
13034 wxColour result;
13035 PyObject * obj0 = 0 ;
13036 PyObject * obj1 = 0 ;
13037 PyObject * obj2 = 0 ;
13038 char *kwnames[] = {
13039 (char *) "self",(char *) "x",(char *) "y", NULL
13040 };
13041
13042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
13043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13044 if (SWIG_arg_fail(1)) SWIG_fail;
13045 {
13046 arg2 = (int)(SWIG_As_int(obj1));
13047 if (SWIG_arg_fail(2)) SWIG_fail;
13048 }
13049 {
13050 arg3 = (int)(SWIG_As_int(obj2));
13051 if (SWIG_arg_fail(3)) SWIG_fail;
13052 }
13053 {
13054 PyThreadState* __tstate = wxPyBeginAllowThreads();
13055 result = wxDC_GetPixel(arg1,arg2,arg3);
13056
13057 wxPyEndAllowThreads(__tstate);
13058 if (PyErr_Occurred()) SWIG_fail;
13059 }
13060 {
13061 wxColour * resultptr;
13062 resultptr = new wxColour((wxColour &)(result));
13063 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13064 }
13065 return resultobj;
13066 fail:
13067 return NULL;
13068 }
13069
13070
13071 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13072 PyObject *resultobj;
13073 wxDC *arg1 = (wxDC *) 0 ;
13074 wxPoint *arg2 = 0 ;
13075 wxColour result;
13076 wxPoint temp2 ;
13077 PyObject * obj0 = 0 ;
13078 PyObject * obj1 = 0 ;
13079 char *kwnames[] = {
13080 (char *) "self",(char *) "pt", NULL
13081 };
13082
13083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
13084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13085 if (SWIG_arg_fail(1)) SWIG_fail;
13086 {
13087 arg2 = &temp2;
13088 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13089 }
13090 {
13091 PyThreadState* __tstate = wxPyBeginAllowThreads();
13092 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
13093
13094 wxPyEndAllowThreads(__tstate);
13095 if (PyErr_Occurred()) SWIG_fail;
13096 }
13097 {
13098 wxColour * resultptr;
13099 resultptr = new wxColour((wxColour &)(result));
13100 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13101 }
13102 return resultobj;
13103 fail:
13104 return NULL;
13105 }
13106
13107
13108 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
13109 PyObject *resultobj;
13110 wxDC *arg1 = (wxDC *) 0 ;
13111 int arg2 ;
13112 int arg3 ;
13113 int arg4 ;
13114 int arg5 ;
13115 PyObject * obj0 = 0 ;
13116 PyObject * obj1 = 0 ;
13117 PyObject * obj2 = 0 ;
13118 PyObject * obj3 = 0 ;
13119 PyObject * obj4 = 0 ;
13120 char *kwnames[] = {
13121 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
13122 };
13123
13124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13126 if (SWIG_arg_fail(1)) SWIG_fail;
13127 {
13128 arg2 = (int)(SWIG_As_int(obj1));
13129 if (SWIG_arg_fail(2)) SWIG_fail;
13130 }
13131 {
13132 arg3 = (int)(SWIG_As_int(obj2));
13133 if (SWIG_arg_fail(3)) SWIG_fail;
13134 }
13135 {
13136 arg4 = (int)(SWIG_As_int(obj3));
13137 if (SWIG_arg_fail(4)) SWIG_fail;
13138 }
13139 {
13140 arg5 = (int)(SWIG_As_int(obj4));
13141 if (SWIG_arg_fail(5)) SWIG_fail;
13142 }
13143 {
13144 PyThreadState* __tstate = wxPyBeginAllowThreads();
13145 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
13146
13147 wxPyEndAllowThreads(__tstate);
13148 if (PyErr_Occurred()) SWIG_fail;
13149 }
13150 Py_INCREF(Py_None); resultobj = Py_None;
13151 return resultobj;
13152 fail:
13153 return NULL;
13154 }
13155
13156
13157 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13158 PyObject *resultobj;
13159 wxDC *arg1 = (wxDC *) 0 ;
13160 wxPoint *arg2 = 0 ;
13161 wxPoint *arg3 = 0 ;
13162 wxPoint temp2 ;
13163 wxPoint temp3 ;
13164 PyObject * obj0 = 0 ;
13165 PyObject * obj1 = 0 ;
13166 PyObject * obj2 = 0 ;
13167 char *kwnames[] = {
13168 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
13169 };
13170
13171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13173 if (SWIG_arg_fail(1)) SWIG_fail;
13174 {
13175 arg2 = &temp2;
13176 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13177 }
13178 {
13179 arg3 = &temp3;
13180 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13181 }
13182 {
13183 PyThreadState* __tstate = wxPyBeginAllowThreads();
13184 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
13185
13186 wxPyEndAllowThreads(__tstate);
13187 if (PyErr_Occurred()) SWIG_fail;
13188 }
13189 Py_INCREF(Py_None); resultobj = Py_None;
13190 return resultobj;
13191 fail:
13192 return NULL;
13193 }
13194
13195
13196 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
13197 PyObject *resultobj;
13198 wxDC *arg1 = (wxDC *) 0 ;
13199 int arg2 ;
13200 int arg3 ;
13201 PyObject * obj0 = 0 ;
13202 PyObject * obj1 = 0 ;
13203 PyObject * obj2 = 0 ;
13204 char *kwnames[] = {
13205 (char *) "self",(char *) "x",(char *) "y", NULL
13206 };
13207
13208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
13209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13210 if (SWIG_arg_fail(1)) SWIG_fail;
13211 {
13212 arg2 = (int)(SWIG_As_int(obj1));
13213 if (SWIG_arg_fail(2)) SWIG_fail;
13214 }
13215 {
13216 arg3 = (int)(SWIG_As_int(obj2));
13217 if (SWIG_arg_fail(3)) SWIG_fail;
13218 }
13219 {
13220 PyThreadState* __tstate = wxPyBeginAllowThreads();
13221 (arg1)->CrossHair(arg2,arg3);
13222
13223 wxPyEndAllowThreads(__tstate);
13224 if (PyErr_Occurred()) SWIG_fail;
13225 }
13226 Py_INCREF(Py_None); resultobj = Py_None;
13227 return resultobj;
13228 fail:
13229 return NULL;
13230 }
13231
13232
13233 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13234 PyObject *resultobj;
13235 wxDC *arg1 = (wxDC *) 0 ;
13236 wxPoint *arg2 = 0 ;
13237 wxPoint temp2 ;
13238 PyObject * obj0 = 0 ;
13239 PyObject * obj1 = 0 ;
13240 char *kwnames[] = {
13241 (char *) "self",(char *) "pt", NULL
13242 };
13243
13244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
13245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13246 if (SWIG_arg_fail(1)) SWIG_fail;
13247 {
13248 arg2 = &temp2;
13249 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13250 }
13251 {
13252 PyThreadState* __tstate = wxPyBeginAllowThreads();
13253 (arg1)->CrossHair((wxPoint const &)*arg2);
13254
13255 wxPyEndAllowThreads(__tstate);
13256 if (PyErr_Occurred()) SWIG_fail;
13257 }
13258 Py_INCREF(Py_None); resultobj = Py_None;
13259 return resultobj;
13260 fail:
13261 return NULL;
13262 }
13263
13264
13265 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
13266 PyObject *resultobj;
13267 wxDC *arg1 = (wxDC *) 0 ;
13268 int arg2 ;
13269 int arg3 ;
13270 int arg4 ;
13271 int arg5 ;
13272 int arg6 ;
13273 int arg7 ;
13274 PyObject * obj0 = 0 ;
13275 PyObject * obj1 = 0 ;
13276 PyObject * obj2 = 0 ;
13277 PyObject * obj3 = 0 ;
13278 PyObject * obj4 = 0 ;
13279 PyObject * obj5 = 0 ;
13280 PyObject * obj6 = 0 ;
13281 char *kwnames[] = {
13282 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
13283 };
13284
13285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13287 if (SWIG_arg_fail(1)) SWIG_fail;
13288 {
13289 arg2 = (int)(SWIG_As_int(obj1));
13290 if (SWIG_arg_fail(2)) SWIG_fail;
13291 }
13292 {
13293 arg3 = (int)(SWIG_As_int(obj2));
13294 if (SWIG_arg_fail(3)) SWIG_fail;
13295 }
13296 {
13297 arg4 = (int)(SWIG_As_int(obj3));
13298 if (SWIG_arg_fail(4)) SWIG_fail;
13299 }
13300 {
13301 arg5 = (int)(SWIG_As_int(obj4));
13302 if (SWIG_arg_fail(5)) SWIG_fail;
13303 }
13304 {
13305 arg6 = (int)(SWIG_As_int(obj5));
13306 if (SWIG_arg_fail(6)) SWIG_fail;
13307 }
13308 {
13309 arg7 = (int)(SWIG_As_int(obj6));
13310 if (SWIG_arg_fail(7)) SWIG_fail;
13311 }
13312 {
13313 PyThreadState* __tstate = wxPyBeginAllowThreads();
13314 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
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_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13327 PyObject *resultobj;
13328 wxDC *arg1 = (wxDC *) 0 ;
13329 wxPoint *arg2 = 0 ;
13330 wxPoint *arg3 = 0 ;
13331 wxPoint *arg4 = 0 ;
13332 wxPoint temp2 ;
13333 wxPoint temp3 ;
13334 wxPoint temp4 ;
13335 PyObject * obj0 = 0 ;
13336 PyObject * obj1 = 0 ;
13337 PyObject * obj2 = 0 ;
13338 PyObject * obj3 = 0 ;
13339 char *kwnames[] = {
13340 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
13341 };
13342
13343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13345 if (SWIG_arg_fail(1)) SWIG_fail;
13346 {
13347 arg2 = &temp2;
13348 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13349 }
13350 {
13351 arg3 = &temp3;
13352 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13353 }
13354 {
13355 arg4 = &temp4;
13356 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
13357 }
13358 {
13359 PyThreadState* __tstate = wxPyBeginAllowThreads();
13360 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
13361
13362 wxPyEndAllowThreads(__tstate);
13363 if (PyErr_Occurred()) SWIG_fail;
13364 }
13365 Py_INCREF(Py_None); resultobj = Py_None;
13366 return resultobj;
13367 fail:
13368 return NULL;
13369 }
13370
13371
13372 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
13373 PyObject *resultobj;
13374 wxDC *arg1 = (wxDC *) 0 ;
13375 int arg2 ;
13376 int arg3 ;
13377 int arg4 ;
13378 int arg5 ;
13379 PyObject * obj0 = 0 ;
13380 PyObject * obj1 = 0 ;
13381 PyObject * obj2 = 0 ;
13382 PyObject * obj3 = 0 ;
13383 PyObject * obj4 = 0 ;
13384 char *kwnames[] = {
13385 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13386 };
13387
13388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13390 if (SWIG_arg_fail(1)) SWIG_fail;
13391 {
13392 arg2 = (int)(SWIG_As_int(obj1));
13393 if (SWIG_arg_fail(2)) SWIG_fail;
13394 }
13395 {
13396 arg3 = (int)(SWIG_As_int(obj2));
13397 if (SWIG_arg_fail(3)) SWIG_fail;
13398 }
13399 {
13400 arg4 = (int)(SWIG_As_int(obj3));
13401 if (SWIG_arg_fail(4)) SWIG_fail;
13402 }
13403 {
13404 arg5 = (int)(SWIG_As_int(obj4));
13405 if (SWIG_arg_fail(5)) SWIG_fail;
13406 }
13407 {
13408 PyThreadState* __tstate = wxPyBeginAllowThreads();
13409 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
13410
13411 wxPyEndAllowThreads(__tstate);
13412 if (PyErr_Occurred()) SWIG_fail;
13413 }
13414 Py_INCREF(Py_None); resultobj = Py_None;
13415 return resultobj;
13416 fail:
13417 return NULL;
13418 }
13419
13420
13421 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
13422 PyObject *resultobj;
13423 wxDC *arg1 = (wxDC *) 0 ;
13424 wxRect *arg2 = 0 ;
13425 wxRect temp2 ;
13426 PyObject * obj0 = 0 ;
13427 PyObject * obj1 = 0 ;
13428 char *kwnames[] = {
13429 (char *) "self",(char *) "rect", NULL
13430 };
13431
13432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
13433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13434 if (SWIG_arg_fail(1)) SWIG_fail;
13435 {
13436 arg2 = &temp2;
13437 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13438 }
13439 {
13440 PyThreadState* __tstate = wxPyBeginAllowThreads();
13441 (arg1)->DrawCheckMark((wxRect const &)*arg2);
13442
13443 wxPyEndAllowThreads(__tstate);
13444 if (PyErr_Occurred()) SWIG_fail;
13445 }
13446 Py_INCREF(Py_None); resultobj = Py_None;
13447 return resultobj;
13448 fail:
13449 return NULL;
13450 }
13451
13452
13453 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
13454 PyObject *resultobj;
13455 wxDC *arg1 = (wxDC *) 0 ;
13456 int arg2 ;
13457 int arg3 ;
13458 int arg4 ;
13459 int arg5 ;
13460 double arg6 ;
13461 double arg7 ;
13462 PyObject * obj0 = 0 ;
13463 PyObject * obj1 = 0 ;
13464 PyObject * obj2 = 0 ;
13465 PyObject * obj3 = 0 ;
13466 PyObject * obj4 = 0 ;
13467 PyObject * obj5 = 0 ;
13468 PyObject * obj6 = 0 ;
13469 char *kwnames[] = {
13470 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
13471 };
13472
13473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13475 if (SWIG_arg_fail(1)) SWIG_fail;
13476 {
13477 arg2 = (int)(SWIG_As_int(obj1));
13478 if (SWIG_arg_fail(2)) SWIG_fail;
13479 }
13480 {
13481 arg3 = (int)(SWIG_As_int(obj2));
13482 if (SWIG_arg_fail(3)) SWIG_fail;
13483 }
13484 {
13485 arg4 = (int)(SWIG_As_int(obj3));
13486 if (SWIG_arg_fail(4)) SWIG_fail;
13487 }
13488 {
13489 arg5 = (int)(SWIG_As_int(obj4));
13490 if (SWIG_arg_fail(5)) SWIG_fail;
13491 }
13492 {
13493 arg6 = (double)(SWIG_As_double(obj5));
13494 if (SWIG_arg_fail(6)) SWIG_fail;
13495 }
13496 {
13497 arg7 = (double)(SWIG_As_double(obj6));
13498 if (SWIG_arg_fail(7)) SWIG_fail;
13499 }
13500 {
13501 PyThreadState* __tstate = wxPyBeginAllowThreads();
13502 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
13503
13504 wxPyEndAllowThreads(__tstate);
13505 if (PyErr_Occurred()) SWIG_fail;
13506 }
13507 Py_INCREF(Py_None); resultobj = Py_None;
13508 return resultobj;
13509 fail:
13510 return NULL;
13511 }
13512
13513
13514 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13515 PyObject *resultobj;
13516 wxDC *arg1 = (wxDC *) 0 ;
13517 wxPoint *arg2 = 0 ;
13518 wxSize *arg3 = 0 ;
13519 double arg4 ;
13520 double arg5 ;
13521 wxPoint temp2 ;
13522 wxSize temp3 ;
13523 PyObject * obj0 = 0 ;
13524 PyObject * obj1 = 0 ;
13525 PyObject * obj2 = 0 ;
13526 PyObject * obj3 = 0 ;
13527 PyObject * obj4 = 0 ;
13528 char *kwnames[] = {
13529 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
13530 };
13531
13532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13534 if (SWIG_arg_fail(1)) SWIG_fail;
13535 {
13536 arg2 = &temp2;
13537 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13538 }
13539 {
13540 arg3 = &temp3;
13541 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13542 }
13543 {
13544 arg4 = (double)(SWIG_As_double(obj3));
13545 if (SWIG_arg_fail(4)) SWIG_fail;
13546 }
13547 {
13548 arg5 = (double)(SWIG_As_double(obj4));
13549 if (SWIG_arg_fail(5)) SWIG_fail;
13550 }
13551 {
13552 PyThreadState* __tstate = wxPyBeginAllowThreads();
13553 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
13554
13555 wxPyEndAllowThreads(__tstate);
13556 if (PyErr_Occurred()) SWIG_fail;
13557 }
13558 Py_INCREF(Py_None); resultobj = Py_None;
13559 return resultobj;
13560 fail:
13561 return NULL;
13562 }
13563
13564
13565 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13566 PyObject *resultobj;
13567 wxDC *arg1 = (wxDC *) 0 ;
13568 int arg2 ;
13569 int arg3 ;
13570 PyObject * obj0 = 0 ;
13571 PyObject * obj1 = 0 ;
13572 PyObject * obj2 = 0 ;
13573 char *kwnames[] = {
13574 (char *) "self",(char *) "x",(char *) "y", NULL
13575 };
13576
13577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13579 if (SWIG_arg_fail(1)) SWIG_fail;
13580 {
13581 arg2 = (int)(SWIG_As_int(obj1));
13582 if (SWIG_arg_fail(2)) SWIG_fail;
13583 }
13584 {
13585 arg3 = (int)(SWIG_As_int(obj2));
13586 if (SWIG_arg_fail(3)) SWIG_fail;
13587 }
13588 {
13589 PyThreadState* __tstate = wxPyBeginAllowThreads();
13590 (arg1)->DrawPoint(arg2,arg3);
13591
13592 wxPyEndAllowThreads(__tstate);
13593 if (PyErr_Occurred()) SWIG_fail;
13594 }
13595 Py_INCREF(Py_None); resultobj = Py_None;
13596 return resultobj;
13597 fail:
13598 return NULL;
13599 }
13600
13601
13602 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13603 PyObject *resultobj;
13604 wxDC *arg1 = (wxDC *) 0 ;
13605 wxPoint *arg2 = 0 ;
13606 wxPoint temp2 ;
13607 PyObject * obj0 = 0 ;
13608 PyObject * obj1 = 0 ;
13609 char *kwnames[] = {
13610 (char *) "self",(char *) "pt", NULL
13611 };
13612
13613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
13614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13615 if (SWIG_arg_fail(1)) SWIG_fail;
13616 {
13617 arg2 = &temp2;
13618 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13619 }
13620 {
13621 PyThreadState* __tstate = wxPyBeginAllowThreads();
13622 (arg1)->DrawPoint((wxPoint const &)*arg2);
13623
13624 wxPyEndAllowThreads(__tstate);
13625 if (PyErr_Occurred()) SWIG_fail;
13626 }
13627 Py_INCREF(Py_None); resultobj = Py_None;
13628 return resultobj;
13629 fail:
13630 return NULL;
13631 }
13632
13633
13634 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13635 PyObject *resultobj;
13636 wxDC *arg1 = (wxDC *) 0 ;
13637 int arg2 ;
13638 int arg3 ;
13639 int arg4 ;
13640 int arg5 ;
13641 PyObject * obj0 = 0 ;
13642 PyObject * obj1 = 0 ;
13643 PyObject * obj2 = 0 ;
13644 PyObject * obj3 = 0 ;
13645 PyObject * obj4 = 0 ;
13646 char *kwnames[] = {
13647 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13648 };
13649
13650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13652 if (SWIG_arg_fail(1)) SWIG_fail;
13653 {
13654 arg2 = (int)(SWIG_As_int(obj1));
13655 if (SWIG_arg_fail(2)) SWIG_fail;
13656 }
13657 {
13658 arg3 = (int)(SWIG_As_int(obj2));
13659 if (SWIG_arg_fail(3)) SWIG_fail;
13660 }
13661 {
13662 arg4 = (int)(SWIG_As_int(obj3));
13663 if (SWIG_arg_fail(4)) SWIG_fail;
13664 }
13665 {
13666 arg5 = (int)(SWIG_As_int(obj4));
13667 if (SWIG_arg_fail(5)) SWIG_fail;
13668 }
13669 {
13670 PyThreadState* __tstate = wxPyBeginAllowThreads();
13671 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13672
13673 wxPyEndAllowThreads(__tstate);
13674 if (PyErr_Occurred()) SWIG_fail;
13675 }
13676 Py_INCREF(Py_None); resultobj = Py_None;
13677 return resultobj;
13678 fail:
13679 return NULL;
13680 }
13681
13682
13683 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13684 PyObject *resultobj;
13685 wxDC *arg1 = (wxDC *) 0 ;
13686 wxRect *arg2 = 0 ;
13687 wxRect temp2 ;
13688 PyObject * obj0 = 0 ;
13689 PyObject * obj1 = 0 ;
13690 char *kwnames[] = {
13691 (char *) "self",(char *) "rect", NULL
13692 };
13693
13694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13696 if (SWIG_arg_fail(1)) SWIG_fail;
13697 {
13698 arg2 = &temp2;
13699 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13700 }
13701 {
13702 PyThreadState* __tstate = wxPyBeginAllowThreads();
13703 (arg1)->DrawRectangle((wxRect const &)*arg2);
13704
13705 wxPyEndAllowThreads(__tstate);
13706 if (PyErr_Occurred()) SWIG_fail;
13707 }
13708 Py_INCREF(Py_None); resultobj = Py_None;
13709 return resultobj;
13710 fail:
13711 return NULL;
13712 }
13713
13714
13715 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13716 PyObject *resultobj;
13717 wxDC *arg1 = (wxDC *) 0 ;
13718 wxPoint *arg2 = 0 ;
13719 wxSize *arg3 = 0 ;
13720 wxPoint temp2 ;
13721 wxSize temp3 ;
13722 PyObject * obj0 = 0 ;
13723 PyObject * obj1 = 0 ;
13724 PyObject * obj2 = 0 ;
13725 char *kwnames[] = {
13726 (char *) "self",(char *) "pt",(char *) "sz", NULL
13727 };
13728
13729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13731 if (SWIG_arg_fail(1)) SWIG_fail;
13732 {
13733 arg2 = &temp2;
13734 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13735 }
13736 {
13737 arg3 = &temp3;
13738 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13739 }
13740 {
13741 PyThreadState* __tstate = wxPyBeginAllowThreads();
13742 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13743
13744 wxPyEndAllowThreads(__tstate);
13745 if (PyErr_Occurred()) SWIG_fail;
13746 }
13747 Py_INCREF(Py_None); resultobj = Py_None;
13748 return resultobj;
13749 fail:
13750 return NULL;
13751 }
13752
13753
13754 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13755 PyObject *resultobj;
13756 wxDC *arg1 = (wxDC *) 0 ;
13757 int arg2 ;
13758 int arg3 ;
13759 int arg4 ;
13760 int arg5 ;
13761 double arg6 ;
13762 PyObject * obj0 = 0 ;
13763 PyObject * obj1 = 0 ;
13764 PyObject * obj2 = 0 ;
13765 PyObject * obj3 = 0 ;
13766 PyObject * obj4 = 0 ;
13767 PyObject * obj5 = 0 ;
13768 char *kwnames[] = {
13769 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13770 };
13771
13772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13774 if (SWIG_arg_fail(1)) SWIG_fail;
13775 {
13776 arg2 = (int)(SWIG_As_int(obj1));
13777 if (SWIG_arg_fail(2)) SWIG_fail;
13778 }
13779 {
13780 arg3 = (int)(SWIG_As_int(obj2));
13781 if (SWIG_arg_fail(3)) SWIG_fail;
13782 }
13783 {
13784 arg4 = (int)(SWIG_As_int(obj3));
13785 if (SWIG_arg_fail(4)) SWIG_fail;
13786 }
13787 {
13788 arg5 = (int)(SWIG_As_int(obj4));
13789 if (SWIG_arg_fail(5)) SWIG_fail;
13790 }
13791 {
13792 arg6 = (double)(SWIG_As_double(obj5));
13793 if (SWIG_arg_fail(6)) SWIG_fail;
13794 }
13795 {
13796 PyThreadState* __tstate = wxPyBeginAllowThreads();
13797 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13798
13799 wxPyEndAllowThreads(__tstate);
13800 if (PyErr_Occurred()) SWIG_fail;
13801 }
13802 Py_INCREF(Py_None); resultobj = Py_None;
13803 return resultobj;
13804 fail:
13805 return NULL;
13806 }
13807
13808
13809 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13810 PyObject *resultobj;
13811 wxDC *arg1 = (wxDC *) 0 ;
13812 wxRect *arg2 = 0 ;
13813 double arg3 ;
13814 wxRect temp2 ;
13815 PyObject * obj0 = 0 ;
13816 PyObject * obj1 = 0 ;
13817 PyObject * obj2 = 0 ;
13818 char *kwnames[] = {
13819 (char *) "self",(char *) "r",(char *) "radius", NULL
13820 };
13821
13822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13824 if (SWIG_arg_fail(1)) SWIG_fail;
13825 {
13826 arg2 = &temp2;
13827 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13828 }
13829 {
13830 arg3 = (double)(SWIG_As_double(obj2));
13831 if (SWIG_arg_fail(3)) SWIG_fail;
13832 }
13833 {
13834 PyThreadState* __tstate = wxPyBeginAllowThreads();
13835 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13836
13837 wxPyEndAllowThreads(__tstate);
13838 if (PyErr_Occurred()) SWIG_fail;
13839 }
13840 Py_INCREF(Py_None); resultobj = Py_None;
13841 return resultobj;
13842 fail:
13843 return NULL;
13844 }
13845
13846
13847 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13848 PyObject *resultobj;
13849 wxDC *arg1 = (wxDC *) 0 ;
13850 wxPoint *arg2 = 0 ;
13851 wxSize *arg3 = 0 ;
13852 double arg4 ;
13853 wxPoint temp2 ;
13854 wxSize temp3 ;
13855 PyObject * obj0 = 0 ;
13856 PyObject * obj1 = 0 ;
13857 PyObject * obj2 = 0 ;
13858 PyObject * obj3 = 0 ;
13859 char *kwnames[] = {
13860 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13861 };
13862
13863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13865 if (SWIG_arg_fail(1)) SWIG_fail;
13866 {
13867 arg2 = &temp2;
13868 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13869 }
13870 {
13871 arg3 = &temp3;
13872 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13873 }
13874 {
13875 arg4 = (double)(SWIG_As_double(obj3));
13876 if (SWIG_arg_fail(4)) SWIG_fail;
13877 }
13878 {
13879 PyThreadState* __tstate = wxPyBeginAllowThreads();
13880 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13881
13882 wxPyEndAllowThreads(__tstate);
13883 if (PyErr_Occurred()) SWIG_fail;
13884 }
13885 Py_INCREF(Py_None); resultobj = Py_None;
13886 return resultobj;
13887 fail:
13888 return NULL;
13889 }
13890
13891
13892 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13893 PyObject *resultobj;
13894 wxDC *arg1 = (wxDC *) 0 ;
13895 int arg2 ;
13896 int arg3 ;
13897 int arg4 ;
13898 PyObject * obj0 = 0 ;
13899 PyObject * obj1 = 0 ;
13900 PyObject * obj2 = 0 ;
13901 PyObject * obj3 = 0 ;
13902 char *kwnames[] = {
13903 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13904 };
13905
13906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13908 if (SWIG_arg_fail(1)) SWIG_fail;
13909 {
13910 arg2 = (int)(SWIG_As_int(obj1));
13911 if (SWIG_arg_fail(2)) SWIG_fail;
13912 }
13913 {
13914 arg3 = (int)(SWIG_As_int(obj2));
13915 if (SWIG_arg_fail(3)) SWIG_fail;
13916 }
13917 {
13918 arg4 = (int)(SWIG_As_int(obj3));
13919 if (SWIG_arg_fail(4)) SWIG_fail;
13920 }
13921 {
13922 PyThreadState* __tstate = wxPyBeginAllowThreads();
13923 (arg1)->DrawCircle(arg2,arg3,arg4);
13924
13925 wxPyEndAllowThreads(__tstate);
13926 if (PyErr_Occurred()) SWIG_fail;
13927 }
13928 Py_INCREF(Py_None); resultobj = Py_None;
13929 return resultobj;
13930 fail:
13931 return NULL;
13932 }
13933
13934
13935 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13936 PyObject *resultobj;
13937 wxDC *arg1 = (wxDC *) 0 ;
13938 wxPoint *arg2 = 0 ;
13939 int arg3 ;
13940 wxPoint temp2 ;
13941 PyObject * obj0 = 0 ;
13942 PyObject * obj1 = 0 ;
13943 PyObject * obj2 = 0 ;
13944 char *kwnames[] = {
13945 (char *) "self",(char *) "pt",(char *) "radius", NULL
13946 };
13947
13948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13950 if (SWIG_arg_fail(1)) SWIG_fail;
13951 {
13952 arg2 = &temp2;
13953 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13954 }
13955 {
13956 arg3 = (int)(SWIG_As_int(obj2));
13957 if (SWIG_arg_fail(3)) SWIG_fail;
13958 }
13959 {
13960 PyThreadState* __tstate = wxPyBeginAllowThreads();
13961 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13962
13963 wxPyEndAllowThreads(__tstate);
13964 if (PyErr_Occurred()) SWIG_fail;
13965 }
13966 Py_INCREF(Py_None); resultobj = Py_None;
13967 return resultobj;
13968 fail:
13969 return NULL;
13970 }
13971
13972
13973 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
13974 PyObject *resultobj;
13975 wxDC *arg1 = (wxDC *) 0 ;
13976 int arg2 ;
13977 int arg3 ;
13978 int arg4 ;
13979 int arg5 ;
13980 PyObject * obj0 = 0 ;
13981 PyObject * obj1 = 0 ;
13982 PyObject * obj2 = 0 ;
13983 PyObject * obj3 = 0 ;
13984 PyObject * obj4 = 0 ;
13985 char *kwnames[] = {
13986 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13987 };
13988
13989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13991 if (SWIG_arg_fail(1)) SWIG_fail;
13992 {
13993 arg2 = (int)(SWIG_As_int(obj1));
13994 if (SWIG_arg_fail(2)) SWIG_fail;
13995 }
13996 {
13997 arg3 = (int)(SWIG_As_int(obj2));
13998 if (SWIG_arg_fail(3)) SWIG_fail;
13999 }
14000 {
14001 arg4 = (int)(SWIG_As_int(obj3));
14002 if (SWIG_arg_fail(4)) SWIG_fail;
14003 }
14004 {
14005 arg5 = (int)(SWIG_As_int(obj4));
14006 if (SWIG_arg_fail(5)) SWIG_fail;
14007 }
14008 {
14009 PyThreadState* __tstate = wxPyBeginAllowThreads();
14010 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
14011
14012 wxPyEndAllowThreads(__tstate);
14013 if (PyErr_Occurred()) SWIG_fail;
14014 }
14015 Py_INCREF(Py_None); resultobj = Py_None;
14016 return resultobj;
14017 fail:
14018 return NULL;
14019 }
14020
14021
14022 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
14023 PyObject *resultobj;
14024 wxDC *arg1 = (wxDC *) 0 ;
14025 wxRect *arg2 = 0 ;
14026 wxRect temp2 ;
14027 PyObject * obj0 = 0 ;
14028 PyObject * obj1 = 0 ;
14029 char *kwnames[] = {
14030 (char *) "self",(char *) "rect", NULL
14031 };
14032
14033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
14034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14035 if (SWIG_arg_fail(1)) SWIG_fail;
14036 {
14037 arg2 = &temp2;
14038 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14039 }
14040 {
14041 PyThreadState* __tstate = wxPyBeginAllowThreads();
14042 (arg1)->DrawEllipse((wxRect const &)*arg2);
14043
14044 wxPyEndAllowThreads(__tstate);
14045 if (PyErr_Occurred()) SWIG_fail;
14046 }
14047 Py_INCREF(Py_None); resultobj = Py_None;
14048 return resultobj;
14049 fail:
14050 return NULL;
14051 }
14052
14053
14054 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14055 PyObject *resultobj;
14056 wxDC *arg1 = (wxDC *) 0 ;
14057 wxPoint *arg2 = 0 ;
14058 wxSize *arg3 = 0 ;
14059 wxPoint temp2 ;
14060 wxSize temp3 ;
14061 PyObject * obj0 = 0 ;
14062 PyObject * obj1 = 0 ;
14063 PyObject * obj2 = 0 ;
14064 char *kwnames[] = {
14065 (char *) "self",(char *) "pt",(char *) "sz", NULL
14066 };
14067
14068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14070 if (SWIG_arg_fail(1)) SWIG_fail;
14071 {
14072 arg2 = &temp2;
14073 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14074 }
14075 {
14076 arg3 = &temp3;
14077 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14078 }
14079 {
14080 PyThreadState* __tstate = wxPyBeginAllowThreads();
14081 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
14082
14083 wxPyEndAllowThreads(__tstate);
14084 if (PyErr_Occurred()) SWIG_fail;
14085 }
14086 Py_INCREF(Py_None); resultobj = Py_None;
14087 return resultobj;
14088 fail:
14089 return NULL;
14090 }
14091
14092
14093 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14094 PyObject *resultobj;
14095 wxDC *arg1 = (wxDC *) 0 ;
14096 wxIcon *arg2 = 0 ;
14097 int arg3 ;
14098 int arg4 ;
14099 PyObject * obj0 = 0 ;
14100 PyObject * obj1 = 0 ;
14101 PyObject * obj2 = 0 ;
14102 PyObject * obj3 = 0 ;
14103 char *kwnames[] = {
14104 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
14105 };
14106
14107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14109 if (SWIG_arg_fail(1)) SWIG_fail;
14110 {
14111 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
14112 if (SWIG_arg_fail(2)) SWIG_fail;
14113 if (arg2 == NULL) {
14114 SWIG_null_ref("wxIcon");
14115 }
14116 if (SWIG_arg_fail(2)) SWIG_fail;
14117 }
14118 {
14119 arg3 = (int)(SWIG_As_int(obj2));
14120 if (SWIG_arg_fail(3)) SWIG_fail;
14121 }
14122 {
14123 arg4 = (int)(SWIG_As_int(obj3));
14124 if (SWIG_arg_fail(4)) SWIG_fail;
14125 }
14126 {
14127 PyThreadState* __tstate = wxPyBeginAllowThreads();
14128 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
14129
14130 wxPyEndAllowThreads(__tstate);
14131 if (PyErr_Occurred()) SWIG_fail;
14132 }
14133 Py_INCREF(Py_None); resultobj = Py_None;
14134 return resultobj;
14135 fail:
14136 return NULL;
14137 }
14138
14139
14140 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14141 PyObject *resultobj;
14142 wxDC *arg1 = (wxDC *) 0 ;
14143 wxIcon *arg2 = 0 ;
14144 wxPoint *arg3 = 0 ;
14145 wxPoint temp3 ;
14146 PyObject * obj0 = 0 ;
14147 PyObject * obj1 = 0 ;
14148 PyObject * obj2 = 0 ;
14149 char *kwnames[] = {
14150 (char *) "self",(char *) "icon",(char *) "pt", NULL
14151 };
14152
14153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
14154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14155 if (SWIG_arg_fail(1)) SWIG_fail;
14156 {
14157 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
14158 if (SWIG_arg_fail(2)) SWIG_fail;
14159 if (arg2 == NULL) {
14160 SWIG_null_ref("wxIcon");
14161 }
14162 if (SWIG_arg_fail(2)) SWIG_fail;
14163 }
14164 {
14165 arg3 = &temp3;
14166 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14167 }
14168 {
14169 PyThreadState* __tstate = wxPyBeginAllowThreads();
14170 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
14171
14172 wxPyEndAllowThreads(__tstate);
14173 if (PyErr_Occurred()) SWIG_fail;
14174 }
14175 Py_INCREF(Py_None); resultobj = Py_None;
14176 return resultobj;
14177 fail:
14178 return NULL;
14179 }
14180
14181
14182 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14183 PyObject *resultobj;
14184 wxDC *arg1 = (wxDC *) 0 ;
14185 wxBitmap *arg2 = 0 ;
14186 int arg3 ;
14187 int arg4 ;
14188 bool arg5 = (bool) false ;
14189 PyObject * obj0 = 0 ;
14190 PyObject * obj1 = 0 ;
14191 PyObject * obj2 = 0 ;
14192 PyObject * obj3 = 0 ;
14193 PyObject * obj4 = 0 ;
14194 char *kwnames[] = {
14195 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
14196 };
14197
14198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14200 if (SWIG_arg_fail(1)) SWIG_fail;
14201 {
14202 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14203 if (SWIG_arg_fail(2)) SWIG_fail;
14204 if (arg2 == NULL) {
14205 SWIG_null_ref("wxBitmap");
14206 }
14207 if (SWIG_arg_fail(2)) SWIG_fail;
14208 }
14209 {
14210 arg3 = (int)(SWIG_As_int(obj2));
14211 if (SWIG_arg_fail(3)) SWIG_fail;
14212 }
14213 {
14214 arg4 = (int)(SWIG_As_int(obj3));
14215 if (SWIG_arg_fail(4)) SWIG_fail;
14216 }
14217 if (obj4) {
14218 {
14219 arg5 = (bool)(SWIG_As_bool(obj4));
14220 if (SWIG_arg_fail(5)) SWIG_fail;
14221 }
14222 }
14223 {
14224 PyThreadState* __tstate = wxPyBeginAllowThreads();
14225 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
14226
14227 wxPyEndAllowThreads(__tstate);
14228 if (PyErr_Occurred()) SWIG_fail;
14229 }
14230 Py_INCREF(Py_None); resultobj = Py_None;
14231 return resultobj;
14232 fail:
14233 return NULL;
14234 }
14235
14236
14237 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14238 PyObject *resultobj;
14239 wxDC *arg1 = (wxDC *) 0 ;
14240 wxBitmap *arg2 = 0 ;
14241 wxPoint *arg3 = 0 ;
14242 bool arg4 = (bool) false ;
14243 wxPoint temp3 ;
14244 PyObject * obj0 = 0 ;
14245 PyObject * obj1 = 0 ;
14246 PyObject * obj2 = 0 ;
14247 PyObject * obj3 = 0 ;
14248 char *kwnames[] = {
14249 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
14250 };
14251
14252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14254 if (SWIG_arg_fail(1)) SWIG_fail;
14255 {
14256 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14257 if (SWIG_arg_fail(2)) SWIG_fail;
14258 if (arg2 == NULL) {
14259 SWIG_null_ref("wxBitmap");
14260 }
14261 if (SWIG_arg_fail(2)) SWIG_fail;
14262 }
14263 {
14264 arg3 = &temp3;
14265 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14266 }
14267 if (obj3) {
14268 {
14269 arg4 = (bool)(SWIG_As_bool(obj3));
14270 if (SWIG_arg_fail(4)) SWIG_fail;
14271 }
14272 }
14273 {
14274 PyThreadState* __tstate = wxPyBeginAllowThreads();
14275 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
14276
14277 wxPyEndAllowThreads(__tstate);
14278 if (PyErr_Occurred()) SWIG_fail;
14279 }
14280 Py_INCREF(Py_None); resultobj = Py_None;
14281 return resultobj;
14282 fail:
14283 return NULL;
14284 }
14285
14286
14287 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
14288 PyObject *resultobj;
14289 wxDC *arg1 = (wxDC *) 0 ;
14290 wxString *arg2 = 0 ;
14291 int arg3 ;
14292 int arg4 ;
14293 bool temp2 = false ;
14294 PyObject * obj0 = 0 ;
14295 PyObject * obj1 = 0 ;
14296 PyObject * obj2 = 0 ;
14297 PyObject * obj3 = 0 ;
14298 char *kwnames[] = {
14299 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
14300 };
14301
14302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14304 if (SWIG_arg_fail(1)) SWIG_fail;
14305 {
14306 arg2 = wxString_in_helper(obj1);
14307 if (arg2 == NULL) SWIG_fail;
14308 temp2 = true;
14309 }
14310 {
14311 arg3 = (int)(SWIG_As_int(obj2));
14312 if (SWIG_arg_fail(3)) SWIG_fail;
14313 }
14314 {
14315 arg4 = (int)(SWIG_As_int(obj3));
14316 if (SWIG_arg_fail(4)) SWIG_fail;
14317 }
14318 {
14319 PyThreadState* __tstate = wxPyBeginAllowThreads();
14320 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
14321
14322 wxPyEndAllowThreads(__tstate);
14323 if (PyErr_Occurred()) SWIG_fail;
14324 }
14325 Py_INCREF(Py_None); resultobj = Py_None;
14326 {
14327 if (temp2)
14328 delete arg2;
14329 }
14330 return resultobj;
14331 fail:
14332 {
14333 if (temp2)
14334 delete arg2;
14335 }
14336 return NULL;
14337 }
14338
14339
14340 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14341 PyObject *resultobj;
14342 wxDC *arg1 = (wxDC *) 0 ;
14343 wxString *arg2 = 0 ;
14344 wxPoint *arg3 = 0 ;
14345 bool temp2 = false ;
14346 wxPoint temp3 ;
14347 PyObject * obj0 = 0 ;
14348 PyObject * obj1 = 0 ;
14349 PyObject * obj2 = 0 ;
14350 char *kwnames[] = {
14351 (char *) "self",(char *) "text",(char *) "pt", NULL
14352 };
14353
14354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
14355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14356 if (SWIG_arg_fail(1)) SWIG_fail;
14357 {
14358 arg2 = wxString_in_helper(obj1);
14359 if (arg2 == NULL) SWIG_fail;
14360 temp2 = true;
14361 }
14362 {
14363 arg3 = &temp3;
14364 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14365 }
14366 {
14367 PyThreadState* __tstate = wxPyBeginAllowThreads();
14368 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
14369
14370 wxPyEndAllowThreads(__tstate);
14371 if (PyErr_Occurred()) SWIG_fail;
14372 }
14373 Py_INCREF(Py_None); resultobj = Py_None;
14374 {
14375 if (temp2)
14376 delete arg2;
14377 }
14378 return resultobj;
14379 fail:
14380 {
14381 if (temp2)
14382 delete arg2;
14383 }
14384 return NULL;
14385 }
14386
14387
14388 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
14389 PyObject *resultobj;
14390 wxDC *arg1 = (wxDC *) 0 ;
14391 wxString *arg2 = 0 ;
14392 int arg3 ;
14393 int arg4 ;
14394 double arg5 ;
14395 bool temp2 = false ;
14396 PyObject * obj0 = 0 ;
14397 PyObject * obj1 = 0 ;
14398 PyObject * obj2 = 0 ;
14399 PyObject * obj3 = 0 ;
14400 PyObject * obj4 = 0 ;
14401 char *kwnames[] = {
14402 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
14403 };
14404
14405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14407 if (SWIG_arg_fail(1)) SWIG_fail;
14408 {
14409 arg2 = wxString_in_helper(obj1);
14410 if (arg2 == NULL) SWIG_fail;
14411 temp2 = true;
14412 }
14413 {
14414 arg3 = (int)(SWIG_As_int(obj2));
14415 if (SWIG_arg_fail(3)) SWIG_fail;
14416 }
14417 {
14418 arg4 = (int)(SWIG_As_int(obj3));
14419 if (SWIG_arg_fail(4)) SWIG_fail;
14420 }
14421 {
14422 arg5 = (double)(SWIG_As_double(obj4));
14423 if (SWIG_arg_fail(5)) SWIG_fail;
14424 }
14425 {
14426 PyThreadState* __tstate = wxPyBeginAllowThreads();
14427 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
14428
14429 wxPyEndAllowThreads(__tstate);
14430 if (PyErr_Occurred()) SWIG_fail;
14431 }
14432 Py_INCREF(Py_None); resultobj = Py_None;
14433 {
14434 if (temp2)
14435 delete arg2;
14436 }
14437 return resultobj;
14438 fail:
14439 {
14440 if (temp2)
14441 delete arg2;
14442 }
14443 return NULL;
14444 }
14445
14446
14447 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14448 PyObject *resultobj;
14449 wxDC *arg1 = (wxDC *) 0 ;
14450 wxString *arg2 = 0 ;
14451 wxPoint *arg3 = 0 ;
14452 double arg4 ;
14453 bool temp2 = false ;
14454 wxPoint temp3 ;
14455 PyObject * obj0 = 0 ;
14456 PyObject * obj1 = 0 ;
14457 PyObject * obj2 = 0 ;
14458 PyObject * obj3 = 0 ;
14459 char *kwnames[] = {
14460 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
14461 };
14462
14463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14465 if (SWIG_arg_fail(1)) SWIG_fail;
14466 {
14467 arg2 = wxString_in_helper(obj1);
14468 if (arg2 == NULL) SWIG_fail;
14469 temp2 = true;
14470 }
14471 {
14472 arg3 = &temp3;
14473 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14474 }
14475 {
14476 arg4 = (double)(SWIG_As_double(obj3));
14477 if (SWIG_arg_fail(4)) SWIG_fail;
14478 }
14479 {
14480 PyThreadState* __tstate = wxPyBeginAllowThreads();
14481 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
14482
14483 wxPyEndAllowThreads(__tstate);
14484 if (PyErr_Occurred()) SWIG_fail;
14485 }
14486 Py_INCREF(Py_None); resultobj = Py_None;
14487 {
14488 if (temp2)
14489 delete arg2;
14490 }
14491 return resultobj;
14492 fail:
14493 {
14494 if (temp2)
14495 delete arg2;
14496 }
14497 return NULL;
14498 }
14499
14500
14501 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
14502 PyObject *resultobj;
14503 wxDC *arg1 = (wxDC *) 0 ;
14504 int arg2 ;
14505 int arg3 ;
14506 int arg4 ;
14507 int arg5 ;
14508 wxDC *arg6 = (wxDC *) 0 ;
14509 int arg7 ;
14510 int arg8 ;
14511 int arg9 = (int) wxCOPY ;
14512 bool arg10 = (bool) false ;
14513 int arg11 = (int) -1 ;
14514 int arg12 = (int) -1 ;
14515 bool result;
14516 PyObject * obj0 = 0 ;
14517 PyObject * obj1 = 0 ;
14518 PyObject * obj2 = 0 ;
14519 PyObject * obj3 = 0 ;
14520 PyObject * obj4 = 0 ;
14521 PyObject * obj5 = 0 ;
14522 PyObject * obj6 = 0 ;
14523 PyObject * obj7 = 0 ;
14524 PyObject * obj8 = 0 ;
14525 PyObject * obj9 = 0 ;
14526 PyObject * obj10 = 0 ;
14527 PyObject * obj11 = 0 ;
14528 char *kwnames[] = {
14529 (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
14530 };
14531
14532 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;
14533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14534 if (SWIG_arg_fail(1)) SWIG_fail;
14535 {
14536 arg2 = (int)(SWIG_As_int(obj1));
14537 if (SWIG_arg_fail(2)) SWIG_fail;
14538 }
14539 {
14540 arg3 = (int)(SWIG_As_int(obj2));
14541 if (SWIG_arg_fail(3)) SWIG_fail;
14542 }
14543 {
14544 arg4 = (int)(SWIG_As_int(obj3));
14545 if (SWIG_arg_fail(4)) SWIG_fail;
14546 }
14547 {
14548 arg5 = (int)(SWIG_As_int(obj4));
14549 if (SWIG_arg_fail(5)) SWIG_fail;
14550 }
14551 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14552 if (SWIG_arg_fail(6)) SWIG_fail;
14553 {
14554 arg7 = (int)(SWIG_As_int(obj6));
14555 if (SWIG_arg_fail(7)) SWIG_fail;
14556 }
14557 {
14558 arg8 = (int)(SWIG_As_int(obj7));
14559 if (SWIG_arg_fail(8)) SWIG_fail;
14560 }
14561 if (obj8) {
14562 {
14563 arg9 = (int)(SWIG_As_int(obj8));
14564 if (SWIG_arg_fail(9)) SWIG_fail;
14565 }
14566 }
14567 if (obj9) {
14568 {
14569 arg10 = (bool)(SWIG_As_bool(obj9));
14570 if (SWIG_arg_fail(10)) SWIG_fail;
14571 }
14572 }
14573 if (obj10) {
14574 {
14575 arg11 = (int)(SWIG_As_int(obj10));
14576 if (SWIG_arg_fail(11)) SWIG_fail;
14577 }
14578 }
14579 if (obj11) {
14580 {
14581 arg12 = (int)(SWIG_As_int(obj11));
14582 if (SWIG_arg_fail(12)) SWIG_fail;
14583 }
14584 }
14585 {
14586 PyThreadState* __tstate = wxPyBeginAllowThreads();
14587 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14588
14589 wxPyEndAllowThreads(__tstate);
14590 if (PyErr_Occurred()) SWIG_fail;
14591 }
14592 {
14593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14594 }
14595 return resultobj;
14596 fail:
14597 return NULL;
14598 }
14599
14600
14601 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14602 PyObject *resultobj;
14603 wxDC *arg1 = (wxDC *) 0 ;
14604 wxPoint *arg2 = 0 ;
14605 wxSize *arg3 = 0 ;
14606 wxDC *arg4 = (wxDC *) 0 ;
14607 wxPoint *arg5 = 0 ;
14608 int arg6 = (int) wxCOPY ;
14609 bool arg7 = (bool) false ;
14610 wxPoint const &arg8_defvalue = wxDefaultPosition ;
14611 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
14612 bool result;
14613 wxPoint temp2 ;
14614 wxSize temp3 ;
14615 wxPoint temp5 ;
14616 wxPoint temp8 ;
14617 PyObject * obj0 = 0 ;
14618 PyObject * obj1 = 0 ;
14619 PyObject * obj2 = 0 ;
14620 PyObject * obj3 = 0 ;
14621 PyObject * obj4 = 0 ;
14622 PyObject * obj5 = 0 ;
14623 PyObject * obj6 = 0 ;
14624 PyObject * obj7 = 0 ;
14625 char *kwnames[] = {
14626 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
14627 };
14628
14629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
14630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14631 if (SWIG_arg_fail(1)) SWIG_fail;
14632 {
14633 arg2 = &temp2;
14634 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14635 }
14636 {
14637 arg3 = &temp3;
14638 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14639 }
14640 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14641 if (SWIG_arg_fail(4)) SWIG_fail;
14642 {
14643 arg5 = &temp5;
14644 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14645 }
14646 if (obj5) {
14647 {
14648 arg6 = (int)(SWIG_As_int(obj5));
14649 if (SWIG_arg_fail(6)) SWIG_fail;
14650 }
14651 }
14652 if (obj6) {
14653 {
14654 arg7 = (bool)(SWIG_As_bool(obj6));
14655 if (SWIG_arg_fail(7)) SWIG_fail;
14656 }
14657 }
14658 if (obj7) {
14659 {
14660 arg8 = &temp8;
14661 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14662 }
14663 }
14664 {
14665 PyThreadState* __tstate = wxPyBeginAllowThreads();
14666 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14667
14668 wxPyEndAllowThreads(__tstate);
14669 if (PyErr_Occurred()) SWIG_fail;
14670 }
14671 {
14672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14673 }
14674 return resultobj;
14675 fail:
14676 return NULL;
14677 }
14678
14679
14680 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14681 PyObject *resultobj;
14682 wxDC *arg1 = (wxDC *) 0 ;
14683 int arg2 ;
14684 int arg3 ;
14685 int arg4 ;
14686 int arg5 ;
14687 PyObject * obj0 = 0 ;
14688 PyObject * obj1 = 0 ;
14689 PyObject * obj2 = 0 ;
14690 PyObject * obj3 = 0 ;
14691 PyObject * obj4 = 0 ;
14692 char *kwnames[] = {
14693 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14694 };
14695
14696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14698 if (SWIG_arg_fail(1)) SWIG_fail;
14699 {
14700 arg2 = (int)(SWIG_As_int(obj1));
14701 if (SWIG_arg_fail(2)) SWIG_fail;
14702 }
14703 {
14704 arg3 = (int)(SWIG_As_int(obj2));
14705 if (SWIG_arg_fail(3)) SWIG_fail;
14706 }
14707 {
14708 arg4 = (int)(SWIG_As_int(obj3));
14709 if (SWIG_arg_fail(4)) SWIG_fail;
14710 }
14711 {
14712 arg5 = (int)(SWIG_As_int(obj4));
14713 if (SWIG_arg_fail(5)) SWIG_fail;
14714 }
14715 {
14716 PyThreadState* __tstate = wxPyBeginAllowThreads();
14717 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14718
14719 wxPyEndAllowThreads(__tstate);
14720 if (PyErr_Occurred()) SWIG_fail;
14721 }
14722 Py_INCREF(Py_None); resultobj = Py_None;
14723 return resultobj;
14724 fail:
14725 return NULL;
14726 }
14727
14728
14729 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14730 PyObject *resultobj;
14731 wxDC *arg1 = (wxDC *) 0 ;
14732 wxPoint *arg2 = 0 ;
14733 wxSize *arg3 = 0 ;
14734 wxPoint temp2 ;
14735 wxSize temp3 ;
14736 PyObject * obj0 = 0 ;
14737 PyObject * obj1 = 0 ;
14738 PyObject * obj2 = 0 ;
14739 char *kwnames[] = {
14740 (char *) "self",(char *) "pt",(char *) "sz", NULL
14741 };
14742
14743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14745 if (SWIG_arg_fail(1)) SWIG_fail;
14746 {
14747 arg2 = &temp2;
14748 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14749 }
14750 {
14751 arg3 = &temp3;
14752 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14753 }
14754 {
14755 PyThreadState* __tstate = wxPyBeginAllowThreads();
14756 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14757
14758 wxPyEndAllowThreads(__tstate);
14759 if (PyErr_Occurred()) SWIG_fail;
14760 }
14761 Py_INCREF(Py_None); resultobj = Py_None;
14762 return resultobj;
14763 fail:
14764 return NULL;
14765 }
14766
14767
14768 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14769 PyObject *resultobj;
14770 wxDC *arg1 = (wxDC *) 0 ;
14771 wxRegion *arg2 = 0 ;
14772 PyObject * obj0 = 0 ;
14773 PyObject * obj1 = 0 ;
14774 char *kwnames[] = {
14775 (char *) "self",(char *) "region", NULL
14776 };
14777
14778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14780 if (SWIG_arg_fail(1)) SWIG_fail;
14781 {
14782 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14783 if (SWIG_arg_fail(2)) SWIG_fail;
14784 if (arg2 == NULL) {
14785 SWIG_null_ref("wxRegion");
14786 }
14787 if (SWIG_arg_fail(2)) SWIG_fail;
14788 }
14789 {
14790 PyThreadState* __tstate = wxPyBeginAllowThreads();
14791 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14792
14793 wxPyEndAllowThreads(__tstate);
14794 if (PyErr_Occurred()) SWIG_fail;
14795 }
14796 Py_INCREF(Py_None); resultobj = Py_None;
14797 return resultobj;
14798 fail:
14799 return NULL;
14800 }
14801
14802
14803 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14804 PyObject *resultobj;
14805 wxDC *arg1 = (wxDC *) 0 ;
14806 wxRect *arg2 = 0 ;
14807 wxRect temp2 ;
14808 PyObject * obj0 = 0 ;
14809 PyObject * obj1 = 0 ;
14810 char *kwnames[] = {
14811 (char *) "self",(char *) "rect", NULL
14812 };
14813
14814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14816 if (SWIG_arg_fail(1)) SWIG_fail;
14817 {
14818 arg2 = &temp2;
14819 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14820 }
14821 {
14822 PyThreadState* __tstate = wxPyBeginAllowThreads();
14823 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14824
14825 wxPyEndAllowThreads(__tstate);
14826 if (PyErr_Occurred()) SWIG_fail;
14827 }
14828 Py_INCREF(Py_None); resultobj = Py_None;
14829 return resultobj;
14830 fail:
14831 return NULL;
14832 }
14833
14834
14835 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14836 PyObject *resultobj;
14837 wxDC *arg1 = (wxDC *) 0 ;
14838 int arg2 ;
14839 wxPoint *arg3 = (wxPoint *) 0 ;
14840 int arg4 = (int) 0 ;
14841 int arg5 = (int) 0 ;
14842 PyObject * obj0 = 0 ;
14843 PyObject * obj1 = 0 ;
14844 PyObject * obj2 = 0 ;
14845 PyObject * obj3 = 0 ;
14846 char *kwnames[] = {
14847 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14848 };
14849
14850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14852 if (SWIG_arg_fail(1)) SWIG_fail;
14853 {
14854 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14855 if (arg3 == NULL) SWIG_fail;
14856 }
14857 if (obj2) {
14858 {
14859 arg4 = (int)(SWIG_As_int(obj2));
14860 if (SWIG_arg_fail(4)) SWIG_fail;
14861 }
14862 }
14863 if (obj3) {
14864 {
14865 arg5 = (int)(SWIG_As_int(obj3));
14866 if (SWIG_arg_fail(5)) SWIG_fail;
14867 }
14868 }
14869 {
14870 PyThreadState* __tstate = wxPyBeginAllowThreads();
14871 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14872
14873 wxPyEndAllowThreads(__tstate);
14874 if (PyErr_Occurred()) SWIG_fail;
14875 }
14876 Py_INCREF(Py_None); resultobj = Py_None;
14877 {
14878 if (arg3) delete [] arg3;
14879 }
14880 return resultobj;
14881 fail:
14882 {
14883 if (arg3) delete [] arg3;
14884 }
14885 return NULL;
14886 }
14887
14888
14889 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14890 PyObject *resultobj;
14891 wxDC *arg1 = (wxDC *) 0 ;
14892 int arg2 ;
14893 wxPoint *arg3 = (wxPoint *) 0 ;
14894 int arg4 = (int) 0 ;
14895 int arg5 = (int) 0 ;
14896 int arg6 = (int) wxODDEVEN_RULE ;
14897 PyObject * obj0 = 0 ;
14898 PyObject * obj1 = 0 ;
14899 PyObject * obj2 = 0 ;
14900 PyObject * obj3 = 0 ;
14901 PyObject * obj4 = 0 ;
14902 char *kwnames[] = {
14903 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14904 };
14905
14906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14908 if (SWIG_arg_fail(1)) SWIG_fail;
14909 {
14910 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14911 if (arg3 == NULL) SWIG_fail;
14912 }
14913 if (obj2) {
14914 {
14915 arg4 = (int)(SWIG_As_int(obj2));
14916 if (SWIG_arg_fail(4)) SWIG_fail;
14917 }
14918 }
14919 if (obj3) {
14920 {
14921 arg5 = (int)(SWIG_As_int(obj3));
14922 if (SWIG_arg_fail(5)) SWIG_fail;
14923 }
14924 }
14925 if (obj4) {
14926 {
14927 arg6 = (int)(SWIG_As_int(obj4));
14928 if (SWIG_arg_fail(6)) SWIG_fail;
14929 }
14930 }
14931 {
14932 PyThreadState* __tstate = wxPyBeginAllowThreads();
14933 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14934
14935 wxPyEndAllowThreads(__tstate);
14936 if (PyErr_Occurred()) SWIG_fail;
14937 }
14938 Py_INCREF(Py_None); resultobj = Py_None;
14939 {
14940 if (arg3) delete [] arg3;
14941 }
14942 return resultobj;
14943 fail:
14944 {
14945 if (arg3) delete [] arg3;
14946 }
14947 return NULL;
14948 }
14949
14950
14951 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14952 PyObject *resultobj;
14953 wxDC *arg1 = (wxDC *) 0 ;
14954 wxString *arg2 = 0 ;
14955 wxRect *arg3 = 0 ;
14956 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14957 int arg5 = (int) -1 ;
14958 bool temp2 = false ;
14959 wxRect temp3 ;
14960 PyObject * obj0 = 0 ;
14961 PyObject * obj1 = 0 ;
14962 PyObject * obj2 = 0 ;
14963 PyObject * obj3 = 0 ;
14964 PyObject * obj4 = 0 ;
14965 char *kwnames[] = {
14966 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14967 };
14968
14969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14971 if (SWIG_arg_fail(1)) SWIG_fail;
14972 {
14973 arg2 = wxString_in_helper(obj1);
14974 if (arg2 == NULL) SWIG_fail;
14975 temp2 = true;
14976 }
14977 {
14978 arg3 = &temp3;
14979 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
14980 }
14981 if (obj3) {
14982 {
14983 arg4 = (int)(SWIG_As_int(obj3));
14984 if (SWIG_arg_fail(4)) SWIG_fail;
14985 }
14986 }
14987 if (obj4) {
14988 {
14989 arg5 = (int)(SWIG_As_int(obj4));
14990 if (SWIG_arg_fail(5)) SWIG_fail;
14991 }
14992 }
14993 {
14994 PyThreadState* __tstate = wxPyBeginAllowThreads();
14995 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
14996
14997 wxPyEndAllowThreads(__tstate);
14998 if (PyErr_Occurred()) SWIG_fail;
14999 }
15000 Py_INCREF(Py_None); resultobj = Py_None;
15001 {
15002 if (temp2)
15003 delete arg2;
15004 }
15005 return resultobj;
15006 fail:
15007 {
15008 if (temp2)
15009 delete arg2;
15010 }
15011 return NULL;
15012 }
15013
15014
15015 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
15016 PyObject *resultobj;
15017 wxDC *arg1 = (wxDC *) 0 ;
15018 wxString *arg2 = 0 ;
15019 wxBitmap *arg3 = 0 ;
15020 wxRect *arg4 = 0 ;
15021 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
15022 int arg6 = (int) -1 ;
15023 wxRect result;
15024 bool temp2 = false ;
15025 wxRect temp4 ;
15026 PyObject * obj0 = 0 ;
15027 PyObject * obj1 = 0 ;
15028 PyObject * obj2 = 0 ;
15029 PyObject * obj3 = 0 ;
15030 PyObject * obj4 = 0 ;
15031 PyObject * obj5 = 0 ;
15032 char *kwnames[] = {
15033 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
15034 };
15035
15036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
15037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15038 if (SWIG_arg_fail(1)) SWIG_fail;
15039 {
15040 arg2 = wxString_in_helper(obj1);
15041 if (arg2 == NULL) SWIG_fail;
15042 temp2 = true;
15043 }
15044 {
15045 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
15046 if (SWIG_arg_fail(3)) SWIG_fail;
15047 if (arg3 == NULL) {
15048 SWIG_null_ref("wxBitmap");
15049 }
15050 if (SWIG_arg_fail(3)) SWIG_fail;
15051 }
15052 {
15053 arg4 = &temp4;
15054 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
15055 }
15056 if (obj4) {
15057 {
15058 arg5 = (int)(SWIG_As_int(obj4));
15059 if (SWIG_arg_fail(5)) SWIG_fail;
15060 }
15061 }
15062 if (obj5) {
15063 {
15064 arg6 = (int)(SWIG_As_int(obj5));
15065 if (SWIG_arg_fail(6)) SWIG_fail;
15066 }
15067 }
15068 {
15069 PyThreadState* __tstate = wxPyBeginAllowThreads();
15070 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
15071
15072 wxPyEndAllowThreads(__tstate);
15073 if (PyErr_Occurred()) SWIG_fail;
15074 }
15075 {
15076 wxRect * resultptr;
15077 resultptr = new wxRect((wxRect &)(result));
15078 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15079 }
15080 {
15081 if (temp2)
15082 delete arg2;
15083 }
15084 return resultobj;
15085 fail:
15086 {
15087 if (temp2)
15088 delete arg2;
15089 }
15090 return NULL;
15091 }
15092
15093
15094 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
15095 PyObject *resultobj;
15096 wxDC *arg1 = (wxDC *) 0 ;
15097 int arg2 ;
15098 wxPoint *arg3 = (wxPoint *) 0 ;
15099 PyObject * obj0 = 0 ;
15100 PyObject * obj1 = 0 ;
15101 char *kwnames[] = {
15102 (char *) "self",(char *) "points", NULL
15103 };
15104
15105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
15106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15107 if (SWIG_arg_fail(1)) SWIG_fail;
15108 {
15109 arg3 = wxPoint_LIST_helper(obj1, &arg2);
15110 if (arg3 == NULL) SWIG_fail;
15111 }
15112 {
15113 PyThreadState* __tstate = wxPyBeginAllowThreads();
15114 (arg1)->DrawSpline(arg2,arg3);
15115
15116 wxPyEndAllowThreads(__tstate);
15117 if (PyErr_Occurred()) SWIG_fail;
15118 }
15119 Py_INCREF(Py_None); resultobj = Py_None;
15120 {
15121 if (arg3) delete [] arg3;
15122 }
15123 return resultobj;
15124 fail:
15125 {
15126 if (arg3) delete [] arg3;
15127 }
15128 return NULL;
15129 }
15130
15131
15132 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
15133 PyObject *resultobj;
15134 wxDC *arg1 = (wxDC *) 0 ;
15135 PyObject * obj0 = 0 ;
15136 char *kwnames[] = {
15137 (char *) "self", NULL
15138 };
15139
15140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
15141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15142 if (SWIG_arg_fail(1)) SWIG_fail;
15143 {
15144 PyThreadState* __tstate = wxPyBeginAllowThreads();
15145 (arg1)->Clear();
15146
15147 wxPyEndAllowThreads(__tstate);
15148 if (PyErr_Occurred()) SWIG_fail;
15149 }
15150 Py_INCREF(Py_None); resultobj = Py_None;
15151 return resultobj;
15152 fail:
15153 return NULL;
15154 }
15155
15156
15157 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
15158 PyObject *resultobj;
15159 wxDC *arg1 = (wxDC *) 0 ;
15160 wxString *arg2 = 0 ;
15161 bool result;
15162 bool temp2 = false ;
15163 PyObject * obj0 = 0 ;
15164 PyObject * obj1 = 0 ;
15165 char *kwnames[] = {
15166 (char *) "self",(char *) "message", NULL
15167 };
15168
15169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
15170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15171 if (SWIG_arg_fail(1)) SWIG_fail;
15172 {
15173 arg2 = wxString_in_helper(obj1);
15174 if (arg2 == NULL) SWIG_fail;
15175 temp2 = true;
15176 }
15177 {
15178 PyThreadState* __tstate = wxPyBeginAllowThreads();
15179 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
15180
15181 wxPyEndAllowThreads(__tstate);
15182 if (PyErr_Occurred()) SWIG_fail;
15183 }
15184 {
15185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15186 }
15187 {
15188 if (temp2)
15189 delete arg2;
15190 }
15191 return resultobj;
15192 fail:
15193 {
15194 if (temp2)
15195 delete arg2;
15196 }
15197 return NULL;
15198 }
15199
15200
15201 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
15202 PyObject *resultobj;
15203 wxDC *arg1 = (wxDC *) 0 ;
15204 PyObject * obj0 = 0 ;
15205 char *kwnames[] = {
15206 (char *) "self", NULL
15207 };
15208
15209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
15210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15211 if (SWIG_arg_fail(1)) SWIG_fail;
15212 {
15213 PyThreadState* __tstate = wxPyBeginAllowThreads();
15214 (arg1)->EndDoc();
15215
15216 wxPyEndAllowThreads(__tstate);
15217 if (PyErr_Occurred()) SWIG_fail;
15218 }
15219 Py_INCREF(Py_None); resultobj = Py_None;
15220 return resultobj;
15221 fail:
15222 return NULL;
15223 }
15224
15225
15226 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
15227 PyObject *resultobj;
15228 wxDC *arg1 = (wxDC *) 0 ;
15229 PyObject * obj0 = 0 ;
15230 char *kwnames[] = {
15231 (char *) "self", NULL
15232 };
15233
15234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
15239 (arg1)->StartPage();
15240
15241 wxPyEndAllowThreads(__tstate);
15242 if (PyErr_Occurred()) SWIG_fail;
15243 }
15244 Py_INCREF(Py_None); resultobj = Py_None;
15245 return resultobj;
15246 fail:
15247 return NULL;
15248 }
15249
15250
15251 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
15252 PyObject *resultobj;
15253 wxDC *arg1 = (wxDC *) 0 ;
15254 PyObject * obj0 = 0 ;
15255 char *kwnames[] = {
15256 (char *) "self", NULL
15257 };
15258
15259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
15260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15261 if (SWIG_arg_fail(1)) SWIG_fail;
15262 {
15263 PyThreadState* __tstate = wxPyBeginAllowThreads();
15264 (arg1)->EndPage();
15265
15266 wxPyEndAllowThreads(__tstate);
15267 if (PyErr_Occurred()) SWIG_fail;
15268 }
15269 Py_INCREF(Py_None); resultobj = Py_None;
15270 return resultobj;
15271 fail:
15272 return NULL;
15273 }
15274
15275
15276 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15277 PyObject *resultobj;
15278 wxDC *arg1 = (wxDC *) 0 ;
15279 wxFont *arg2 = 0 ;
15280 PyObject * obj0 = 0 ;
15281 PyObject * obj1 = 0 ;
15282 char *kwnames[] = {
15283 (char *) "self",(char *) "font", NULL
15284 };
15285
15286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
15287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15288 if (SWIG_arg_fail(1)) SWIG_fail;
15289 {
15290 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15291 if (SWIG_arg_fail(2)) SWIG_fail;
15292 if (arg2 == NULL) {
15293 SWIG_null_ref("wxFont");
15294 }
15295 if (SWIG_arg_fail(2)) SWIG_fail;
15296 }
15297 {
15298 PyThreadState* __tstate = wxPyBeginAllowThreads();
15299 (arg1)->SetFont((wxFont const &)*arg2);
15300
15301 wxPyEndAllowThreads(__tstate);
15302 if (PyErr_Occurred()) SWIG_fail;
15303 }
15304 Py_INCREF(Py_None); resultobj = Py_None;
15305 return resultobj;
15306 fail:
15307 return NULL;
15308 }
15309
15310
15311 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
15312 PyObject *resultobj;
15313 wxDC *arg1 = (wxDC *) 0 ;
15314 wxPen *arg2 = 0 ;
15315 PyObject * obj0 = 0 ;
15316 PyObject * obj1 = 0 ;
15317 char *kwnames[] = {
15318 (char *) "self",(char *) "pen", NULL
15319 };
15320
15321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
15322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15323 if (SWIG_arg_fail(1)) SWIG_fail;
15324 {
15325 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
15326 if (SWIG_arg_fail(2)) SWIG_fail;
15327 if (arg2 == NULL) {
15328 SWIG_null_ref("wxPen");
15329 }
15330 if (SWIG_arg_fail(2)) SWIG_fail;
15331 }
15332 {
15333 PyThreadState* __tstate = wxPyBeginAllowThreads();
15334 (arg1)->SetPen((wxPen const &)*arg2);
15335
15336 wxPyEndAllowThreads(__tstate);
15337 if (PyErr_Occurred()) SWIG_fail;
15338 }
15339 Py_INCREF(Py_None); resultobj = Py_None;
15340 return resultobj;
15341 fail:
15342 return NULL;
15343 }
15344
15345
15346 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15347 PyObject *resultobj;
15348 wxDC *arg1 = (wxDC *) 0 ;
15349 wxBrush *arg2 = 0 ;
15350 PyObject * obj0 = 0 ;
15351 PyObject * obj1 = 0 ;
15352 char *kwnames[] = {
15353 (char *) "self",(char *) "brush", NULL
15354 };
15355
15356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
15357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15358 if (SWIG_arg_fail(1)) SWIG_fail;
15359 {
15360 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
15361 if (SWIG_arg_fail(2)) SWIG_fail;
15362 if (arg2 == NULL) {
15363 SWIG_null_ref("wxBrush");
15364 }
15365 if (SWIG_arg_fail(2)) SWIG_fail;
15366 }
15367 {
15368 PyThreadState* __tstate = wxPyBeginAllowThreads();
15369 (arg1)->SetBrush((wxBrush const &)*arg2);
15370
15371 wxPyEndAllowThreads(__tstate);
15372 if (PyErr_Occurred()) SWIG_fail;
15373 }
15374 Py_INCREF(Py_None); resultobj = Py_None;
15375 return resultobj;
15376 fail:
15377 return NULL;
15378 }
15379
15380
15381 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15382 PyObject *resultobj;
15383 wxDC *arg1 = (wxDC *) 0 ;
15384 wxBrush *arg2 = 0 ;
15385 PyObject * obj0 = 0 ;
15386 PyObject * obj1 = 0 ;
15387 char *kwnames[] = {
15388 (char *) "self",(char *) "brush", NULL
15389 };
15390
15391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
15392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15393 if (SWIG_arg_fail(1)) SWIG_fail;
15394 {
15395 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
15396 if (SWIG_arg_fail(2)) SWIG_fail;
15397 if (arg2 == NULL) {
15398 SWIG_null_ref("wxBrush");
15399 }
15400 if (SWIG_arg_fail(2)) SWIG_fail;
15401 }
15402 {
15403 PyThreadState* __tstate = wxPyBeginAllowThreads();
15404 (arg1)->SetBackground((wxBrush const &)*arg2);
15405
15406 wxPyEndAllowThreads(__tstate);
15407 if (PyErr_Occurred()) SWIG_fail;
15408 }
15409 Py_INCREF(Py_None); resultobj = Py_None;
15410 return resultobj;
15411 fail:
15412 return NULL;
15413 }
15414
15415
15416 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15417 PyObject *resultobj;
15418 wxDC *arg1 = (wxDC *) 0 ;
15419 int arg2 ;
15420 PyObject * obj0 = 0 ;
15421 PyObject * obj1 = 0 ;
15422 char *kwnames[] = {
15423 (char *) "self",(char *) "mode", NULL
15424 };
15425
15426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
15427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15428 if (SWIG_arg_fail(1)) SWIG_fail;
15429 {
15430 arg2 = (int)(SWIG_As_int(obj1));
15431 if (SWIG_arg_fail(2)) SWIG_fail;
15432 }
15433 {
15434 PyThreadState* __tstate = wxPyBeginAllowThreads();
15435 (arg1)->SetBackgroundMode(arg2);
15436
15437 wxPyEndAllowThreads(__tstate);
15438 if (PyErr_Occurred()) SWIG_fail;
15439 }
15440 Py_INCREF(Py_None); resultobj = Py_None;
15441 return resultobj;
15442 fail:
15443 return NULL;
15444 }
15445
15446
15447 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
15448 PyObject *resultobj;
15449 wxDC *arg1 = (wxDC *) 0 ;
15450 wxPalette *arg2 = 0 ;
15451 PyObject * obj0 = 0 ;
15452 PyObject * obj1 = 0 ;
15453 char *kwnames[] = {
15454 (char *) "self",(char *) "palette", NULL
15455 };
15456
15457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
15458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15459 if (SWIG_arg_fail(1)) SWIG_fail;
15460 {
15461 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
15462 if (SWIG_arg_fail(2)) SWIG_fail;
15463 if (arg2 == NULL) {
15464 SWIG_null_ref("wxPalette");
15465 }
15466 if (SWIG_arg_fail(2)) SWIG_fail;
15467 }
15468 {
15469 PyThreadState* __tstate = wxPyBeginAllowThreads();
15470 (arg1)->SetPalette((wxPalette const &)*arg2);
15471
15472 wxPyEndAllowThreads(__tstate);
15473 if (PyErr_Occurred()) SWIG_fail;
15474 }
15475 Py_INCREF(Py_None); resultobj = Py_None;
15476 return resultobj;
15477 fail:
15478 return NULL;
15479 }
15480
15481
15482 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
15483 PyObject *resultobj;
15484 wxDC *arg1 = (wxDC *) 0 ;
15485 PyObject * obj0 = 0 ;
15486 char *kwnames[] = {
15487 (char *) "self", NULL
15488 };
15489
15490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
15491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15492 if (SWIG_arg_fail(1)) SWIG_fail;
15493 {
15494 PyThreadState* __tstate = wxPyBeginAllowThreads();
15495 (arg1)->DestroyClippingRegion();
15496
15497 wxPyEndAllowThreads(__tstate);
15498 if (PyErr_Occurred()) SWIG_fail;
15499 }
15500 Py_INCREF(Py_None); resultobj = Py_None;
15501 return resultobj;
15502 fail:
15503 return NULL;
15504 }
15505
15506
15507 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
15508 PyObject *resultobj;
15509 wxDC *arg1 = (wxDC *) 0 ;
15510 int *arg2 = (int *) 0 ;
15511 int *arg3 = (int *) 0 ;
15512 int *arg4 = (int *) 0 ;
15513 int *arg5 = (int *) 0 ;
15514 int temp2 ;
15515 int res2 = 0 ;
15516 int temp3 ;
15517 int res3 = 0 ;
15518 int temp4 ;
15519 int res4 = 0 ;
15520 int temp5 ;
15521 int res5 = 0 ;
15522 PyObject * obj0 = 0 ;
15523 char *kwnames[] = {
15524 (char *) "self", NULL
15525 };
15526
15527 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15528 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15529 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15530 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
15532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15533 if (SWIG_arg_fail(1)) SWIG_fail;
15534 {
15535 PyThreadState* __tstate = wxPyBeginAllowThreads();
15536 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
15537
15538 wxPyEndAllowThreads(__tstate);
15539 if (PyErr_Occurred()) SWIG_fail;
15540 }
15541 Py_INCREF(Py_None); resultobj = Py_None;
15542 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15543 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15544 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15545 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15546 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15547 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15548 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15549 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15550 return resultobj;
15551 fail:
15552 return NULL;
15553 }
15554
15555
15556 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
15557 PyObject *resultobj;
15558 wxDC *arg1 = (wxDC *) 0 ;
15559 wxRect result;
15560 PyObject * obj0 = 0 ;
15561 char *kwnames[] = {
15562 (char *) "self", NULL
15563 };
15564
15565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
15566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15567 if (SWIG_arg_fail(1)) SWIG_fail;
15568 {
15569 PyThreadState* __tstate = wxPyBeginAllowThreads();
15570 result = wxDC_GetClippingRect(arg1);
15571
15572 wxPyEndAllowThreads(__tstate);
15573 if (PyErr_Occurred()) SWIG_fail;
15574 }
15575 {
15576 wxRect * resultptr;
15577 resultptr = new wxRect((wxRect &)(result));
15578 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15579 }
15580 return resultobj;
15581 fail:
15582 return NULL;
15583 }
15584
15585
15586 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
15587 PyObject *resultobj;
15588 wxDC *arg1 = (wxDC *) 0 ;
15589 int result;
15590 PyObject * obj0 = 0 ;
15591 char *kwnames[] = {
15592 (char *) "self", NULL
15593 };
15594
15595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
15596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15597 if (SWIG_arg_fail(1)) SWIG_fail;
15598 {
15599 PyThreadState* __tstate = wxPyBeginAllowThreads();
15600 result = (int)((wxDC const *)arg1)->GetCharHeight();
15601
15602 wxPyEndAllowThreads(__tstate);
15603 if (PyErr_Occurred()) SWIG_fail;
15604 }
15605 {
15606 resultobj = SWIG_From_int((int)(result));
15607 }
15608 return resultobj;
15609 fail:
15610 return NULL;
15611 }
15612
15613
15614 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
15615 PyObject *resultobj;
15616 wxDC *arg1 = (wxDC *) 0 ;
15617 int result;
15618 PyObject * obj0 = 0 ;
15619 char *kwnames[] = {
15620 (char *) "self", NULL
15621 };
15622
15623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
15624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15625 if (SWIG_arg_fail(1)) SWIG_fail;
15626 {
15627 PyThreadState* __tstate = wxPyBeginAllowThreads();
15628 result = (int)((wxDC const *)arg1)->GetCharWidth();
15629
15630 wxPyEndAllowThreads(__tstate);
15631 if (PyErr_Occurred()) SWIG_fail;
15632 }
15633 {
15634 resultobj = SWIG_From_int((int)(result));
15635 }
15636 return resultobj;
15637 fail:
15638 return NULL;
15639 }
15640
15641
15642 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15643 PyObject *resultobj;
15644 wxDC *arg1 = (wxDC *) 0 ;
15645 wxString *arg2 = 0 ;
15646 int *arg3 = (int *) 0 ;
15647 int *arg4 = (int *) 0 ;
15648 bool temp2 = false ;
15649 int temp3 ;
15650 int res3 = 0 ;
15651 int temp4 ;
15652 int res4 = 0 ;
15653 PyObject * obj0 = 0 ;
15654 PyObject * obj1 = 0 ;
15655 char *kwnames[] = {
15656 (char *) "self",(char *) "string", NULL
15657 };
15658
15659 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15660 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15663 if (SWIG_arg_fail(1)) SWIG_fail;
15664 {
15665 arg2 = wxString_in_helper(obj1);
15666 if (arg2 == NULL) SWIG_fail;
15667 temp2 = true;
15668 }
15669 {
15670 PyThreadState* __tstate = wxPyBeginAllowThreads();
15671 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15672
15673 wxPyEndAllowThreads(__tstate);
15674 if (PyErr_Occurred()) SWIG_fail;
15675 }
15676 Py_INCREF(Py_None); resultobj = Py_None;
15677 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15678 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15679 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15680 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15681 {
15682 if (temp2)
15683 delete arg2;
15684 }
15685 return resultobj;
15686 fail:
15687 {
15688 if (temp2)
15689 delete arg2;
15690 }
15691 return NULL;
15692 }
15693
15694
15695 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15696 PyObject *resultobj;
15697 wxDC *arg1 = (wxDC *) 0 ;
15698 wxString *arg2 = 0 ;
15699 int *arg3 = (int *) 0 ;
15700 int *arg4 = (int *) 0 ;
15701 int *arg5 = (int *) 0 ;
15702 int *arg6 = (int *) 0 ;
15703 wxFont *arg7 = (wxFont *) NULL ;
15704 bool temp2 = false ;
15705 int temp3 ;
15706 int res3 = 0 ;
15707 int temp4 ;
15708 int res4 = 0 ;
15709 int temp5 ;
15710 int res5 = 0 ;
15711 int temp6 ;
15712 int res6 = 0 ;
15713 PyObject * obj0 = 0 ;
15714 PyObject * obj1 = 0 ;
15715 PyObject * obj2 = 0 ;
15716 char *kwnames[] = {
15717 (char *) "self",(char *) "string",(char *) "font", NULL
15718 };
15719
15720 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15721 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15722 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15723 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15726 if (SWIG_arg_fail(1)) SWIG_fail;
15727 {
15728 arg2 = wxString_in_helper(obj1);
15729 if (arg2 == NULL) SWIG_fail;
15730 temp2 = true;
15731 }
15732 if (obj2) {
15733 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15734 if (SWIG_arg_fail(7)) SWIG_fail;
15735 }
15736 {
15737 PyThreadState* __tstate = wxPyBeginAllowThreads();
15738 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15739
15740 wxPyEndAllowThreads(__tstate);
15741 if (PyErr_Occurred()) SWIG_fail;
15742 }
15743 Py_INCREF(Py_None); resultobj = Py_None;
15744 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15745 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15746 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15747 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15748 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15749 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15750 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15751 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15752 {
15753 if (temp2)
15754 delete arg2;
15755 }
15756 return resultobj;
15757 fail:
15758 {
15759 if (temp2)
15760 delete arg2;
15761 }
15762 return NULL;
15763 }
15764
15765
15766 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15767 PyObject *resultobj;
15768 wxDC *arg1 = (wxDC *) 0 ;
15769 wxString *arg2 = 0 ;
15770 int *arg3 = (int *) 0 ;
15771 int *arg4 = (int *) 0 ;
15772 int *arg5 = (int *) 0 ;
15773 wxFont *arg6 = (wxFont *) NULL ;
15774 bool temp2 = false ;
15775 int temp3 ;
15776 int res3 = 0 ;
15777 int temp4 ;
15778 int res4 = 0 ;
15779 int temp5 ;
15780 int res5 = 0 ;
15781 PyObject * obj0 = 0 ;
15782 PyObject * obj1 = 0 ;
15783 PyObject * obj2 = 0 ;
15784 char *kwnames[] = {
15785 (char *) "self",(char *) "text",(char *) "font", NULL
15786 };
15787
15788 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15789 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15790 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15793 if (SWIG_arg_fail(1)) SWIG_fail;
15794 {
15795 arg2 = wxString_in_helper(obj1);
15796 if (arg2 == NULL) SWIG_fail;
15797 temp2 = true;
15798 }
15799 if (obj2) {
15800 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15801 if (SWIG_arg_fail(6)) SWIG_fail;
15802 }
15803 {
15804 PyThreadState* __tstate = wxPyBeginAllowThreads();
15805 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15806
15807 wxPyEndAllowThreads(__tstate);
15808 if (PyErr_Occurred()) SWIG_fail;
15809 }
15810 Py_INCREF(Py_None); resultobj = Py_None;
15811 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15812 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15813 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15814 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15815 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15816 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15817 {
15818 if (temp2)
15819 delete arg2;
15820 }
15821 return resultobj;
15822 fail:
15823 {
15824 if (temp2)
15825 delete arg2;
15826 }
15827 return NULL;
15828 }
15829
15830
15831 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15832 PyObject *resultobj;
15833 wxDC *arg1 = (wxDC *) 0 ;
15834 wxString *arg2 = 0 ;
15835 wxArrayInt result;
15836 bool temp2 = false ;
15837 PyObject * obj0 = 0 ;
15838 PyObject * obj1 = 0 ;
15839 char *kwnames[] = {
15840 (char *) "self",(char *) "text", NULL
15841 };
15842
15843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15845 if (SWIG_arg_fail(1)) SWIG_fail;
15846 {
15847 arg2 = wxString_in_helper(obj1);
15848 if (arg2 == NULL) SWIG_fail;
15849 temp2 = true;
15850 }
15851 {
15852 PyThreadState* __tstate = wxPyBeginAllowThreads();
15853 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15854
15855 wxPyEndAllowThreads(__tstate);
15856 if (PyErr_Occurred()) SWIG_fail;
15857 }
15858 {
15859 resultobj = PyList_New(0);
15860 size_t idx;
15861 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15862 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15863 PyList_Append(resultobj, val);
15864 Py_DECREF(val);
15865 }
15866 }
15867 {
15868 if (temp2)
15869 delete arg2;
15870 }
15871 return resultobj;
15872 fail:
15873 {
15874 if (temp2)
15875 delete arg2;
15876 }
15877 return NULL;
15878 }
15879
15880
15881 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15882 PyObject *resultobj;
15883 wxDC *arg1 = (wxDC *) 0 ;
15884 wxSize result;
15885 PyObject * obj0 = 0 ;
15886 char *kwnames[] = {
15887 (char *) "self", NULL
15888 };
15889
15890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15892 if (SWIG_arg_fail(1)) SWIG_fail;
15893 {
15894 PyThreadState* __tstate = wxPyBeginAllowThreads();
15895 result = (arg1)->GetSize();
15896
15897 wxPyEndAllowThreads(__tstate);
15898 if (PyErr_Occurred()) SWIG_fail;
15899 }
15900 {
15901 wxSize * resultptr;
15902 resultptr = new wxSize((wxSize &)(result));
15903 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15904 }
15905 return resultobj;
15906 fail:
15907 return NULL;
15908 }
15909
15910
15911 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15912 PyObject *resultobj;
15913 wxDC *arg1 = (wxDC *) 0 ;
15914 int *arg2 = (int *) 0 ;
15915 int *arg3 = (int *) 0 ;
15916 int temp2 ;
15917 int res2 = 0 ;
15918 int temp3 ;
15919 int res3 = 0 ;
15920 PyObject * obj0 = 0 ;
15921 char *kwnames[] = {
15922 (char *) "self", NULL
15923 };
15924
15925 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15926 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15929 if (SWIG_arg_fail(1)) SWIG_fail;
15930 {
15931 PyThreadState* __tstate = wxPyBeginAllowThreads();
15932 (arg1)->GetSize(arg2,arg3);
15933
15934 wxPyEndAllowThreads(__tstate);
15935 if (PyErr_Occurred()) SWIG_fail;
15936 }
15937 Py_INCREF(Py_None); resultobj = Py_None;
15938 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15939 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15940 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15941 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15942 return resultobj;
15943 fail:
15944 return NULL;
15945 }
15946
15947
15948 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15949 PyObject *resultobj;
15950 wxDC *arg1 = (wxDC *) 0 ;
15951 wxSize result;
15952 PyObject * obj0 = 0 ;
15953 char *kwnames[] = {
15954 (char *) "self", NULL
15955 };
15956
15957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
15958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15959 if (SWIG_arg_fail(1)) SWIG_fail;
15960 {
15961 PyThreadState* __tstate = wxPyBeginAllowThreads();
15962 result = ((wxDC const *)arg1)->GetSizeMM();
15963
15964 wxPyEndAllowThreads(__tstate);
15965 if (PyErr_Occurred()) SWIG_fail;
15966 }
15967 {
15968 wxSize * resultptr;
15969 resultptr = new wxSize((wxSize &)(result));
15970 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15971 }
15972 return resultobj;
15973 fail:
15974 return NULL;
15975 }
15976
15977
15978 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15979 PyObject *resultobj;
15980 wxDC *arg1 = (wxDC *) 0 ;
15981 int *arg2 = (int *) 0 ;
15982 int *arg3 = (int *) 0 ;
15983 int temp2 ;
15984 int res2 = 0 ;
15985 int temp3 ;
15986 int res3 = 0 ;
15987 PyObject * obj0 = 0 ;
15988 char *kwnames[] = {
15989 (char *) "self", NULL
15990 };
15991
15992 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15993 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
15995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15996 if (SWIG_arg_fail(1)) SWIG_fail;
15997 {
15998 PyThreadState* __tstate = wxPyBeginAllowThreads();
15999 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
16000
16001 wxPyEndAllowThreads(__tstate);
16002 if (PyErr_Occurred()) SWIG_fail;
16003 }
16004 Py_INCREF(Py_None); resultobj = Py_None;
16005 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16006 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16007 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16008 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16009 return resultobj;
16010 fail:
16011 return NULL;
16012 }
16013
16014
16015 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
16016 PyObject *resultobj;
16017 wxDC *arg1 = (wxDC *) 0 ;
16018 int arg2 ;
16019 int result;
16020 PyObject * obj0 = 0 ;
16021 PyObject * obj1 = 0 ;
16022 char *kwnames[] = {
16023 (char *) "self",(char *) "x", NULL
16024 };
16025
16026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
16027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16028 if (SWIG_arg_fail(1)) SWIG_fail;
16029 {
16030 arg2 = (int)(SWIG_As_int(obj1));
16031 if (SWIG_arg_fail(2)) SWIG_fail;
16032 }
16033 {
16034 PyThreadState* __tstate = wxPyBeginAllowThreads();
16035 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
16036
16037 wxPyEndAllowThreads(__tstate);
16038 if (PyErr_Occurred()) SWIG_fail;
16039 }
16040 {
16041 resultobj = SWIG_From_int((int)(result));
16042 }
16043 return resultobj;
16044 fail:
16045 return NULL;
16046 }
16047
16048
16049 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
16050 PyObject *resultobj;
16051 wxDC *arg1 = (wxDC *) 0 ;
16052 int arg2 ;
16053 int result;
16054 PyObject * obj0 = 0 ;
16055 PyObject * obj1 = 0 ;
16056 char *kwnames[] = {
16057 (char *) "self",(char *) "y", NULL
16058 };
16059
16060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
16061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16062 if (SWIG_arg_fail(1)) SWIG_fail;
16063 {
16064 arg2 = (int)(SWIG_As_int(obj1));
16065 if (SWIG_arg_fail(2)) SWIG_fail;
16066 }
16067 {
16068 PyThreadState* __tstate = wxPyBeginAllowThreads();
16069 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
16070
16071 wxPyEndAllowThreads(__tstate);
16072 if (PyErr_Occurred()) SWIG_fail;
16073 }
16074 {
16075 resultobj = SWIG_From_int((int)(result));
16076 }
16077 return resultobj;
16078 fail:
16079 return NULL;
16080 }
16081
16082
16083 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
16084 PyObject *resultobj;
16085 wxDC *arg1 = (wxDC *) 0 ;
16086 int arg2 ;
16087 int result;
16088 PyObject * obj0 = 0 ;
16089 PyObject * obj1 = 0 ;
16090 char *kwnames[] = {
16091 (char *) "self",(char *) "x", NULL
16092 };
16093
16094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
16095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16096 if (SWIG_arg_fail(1)) SWIG_fail;
16097 {
16098 arg2 = (int)(SWIG_As_int(obj1));
16099 if (SWIG_arg_fail(2)) SWIG_fail;
16100 }
16101 {
16102 PyThreadState* __tstate = wxPyBeginAllowThreads();
16103 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
16104
16105 wxPyEndAllowThreads(__tstate);
16106 if (PyErr_Occurred()) SWIG_fail;
16107 }
16108 {
16109 resultobj = SWIG_From_int((int)(result));
16110 }
16111 return resultobj;
16112 fail:
16113 return NULL;
16114 }
16115
16116
16117 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
16118 PyObject *resultobj;
16119 wxDC *arg1 = (wxDC *) 0 ;
16120 int arg2 ;
16121 int result;
16122 PyObject * obj0 = 0 ;
16123 PyObject * obj1 = 0 ;
16124 char *kwnames[] = {
16125 (char *) "self",(char *) "y", NULL
16126 };
16127
16128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
16129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16130 if (SWIG_arg_fail(1)) SWIG_fail;
16131 {
16132 arg2 = (int)(SWIG_As_int(obj1));
16133 if (SWIG_arg_fail(2)) SWIG_fail;
16134 }
16135 {
16136 PyThreadState* __tstate = wxPyBeginAllowThreads();
16137 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
16138
16139 wxPyEndAllowThreads(__tstate);
16140 if (PyErr_Occurred()) SWIG_fail;
16141 }
16142 {
16143 resultobj = SWIG_From_int((int)(result));
16144 }
16145 return resultobj;
16146 fail:
16147 return NULL;
16148 }
16149
16150
16151 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
16152 PyObject *resultobj;
16153 wxDC *arg1 = (wxDC *) 0 ;
16154 int arg2 ;
16155 int result;
16156 PyObject * obj0 = 0 ;
16157 PyObject * obj1 = 0 ;
16158 char *kwnames[] = {
16159 (char *) "self",(char *) "x", NULL
16160 };
16161
16162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
16163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16164 if (SWIG_arg_fail(1)) SWIG_fail;
16165 {
16166 arg2 = (int)(SWIG_As_int(obj1));
16167 if (SWIG_arg_fail(2)) SWIG_fail;
16168 }
16169 {
16170 PyThreadState* __tstate = wxPyBeginAllowThreads();
16171 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
16172
16173 wxPyEndAllowThreads(__tstate);
16174 if (PyErr_Occurred()) SWIG_fail;
16175 }
16176 {
16177 resultobj = SWIG_From_int((int)(result));
16178 }
16179 return resultobj;
16180 fail:
16181 return NULL;
16182 }
16183
16184
16185 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
16186 PyObject *resultobj;
16187 wxDC *arg1 = (wxDC *) 0 ;
16188 int arg2 ;
16189 int result;
16190 PyObject * obj0 = 0 ;
16191 PyObject * obj1 = 0 ;
16192 char *kwnames[] = {
16193 (char *) "self",(char *) "y", NULL
16194 };
16195
16196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
16197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16198 if (SWIG_arg_fail(1)) SWIG_fail;
16199 {
16200 arg2 = (int)(SWIG_As_int(obj1));
16201 if (SWIG_arg_fail(2)) SWIG_fail;
16202 }
16203 {
16204 PyThreadState* __tstate = wxPyBeginAllowThreads();
16205 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
16206
16207 wxPyEndAllowThreads(__tstate);
16208 if (PyErr_Occurred()) SWIG_fail;
16209 }
16210 {
16211 resultobj = SWIG_From_int((int)(result));
16212 }
16213 return resultobj;
16214 fail:
16215 return NULL;
16216 }
16217
16218
16219 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
16220 PyObject *resultobj;
16221 wxDC *arg1 = (wxDC *) 0 ;
16222 int arg2 ;
16223 int result;
16224 PyObject * obj0 = 0 ;
16225 PyObject * obj1 = 0 ;
16226 char *kwnames[] = {
16227 (char *) "self",(char *) "x", NULL
16228 };
16229
16230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
16231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16232 if (SWIG_arg_fail(1)) SWIG_fail;
16233 {
16234 arg2 = (int)(SWIG_As_int(obj1));
16235 if (SWIG_arg_fail(2)) SWIG_fail;
16236 }
16237 {
16238 PyThreadState* __tstate = wxPyBeginAllowThreads();
16239 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
16240
16241 wxPyEndAllowThreads(__tstate);
16242 if (PyErr_Occurred()) SWIG_fail;
16243 }
16244 {
16245 resultobj = SWIG_From_int((int)(result));
16246 }
16247 return resultobj;
16248 fail:
16249 return NULL;
16250 }
16251
16252
16253 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
16254 PyObject *resultobj;
16255 wxDC *arg1 = (wxDC *) 0 ;
16256 int arg2 ;
16257 int result;
16258 PyObject * obj0 = 0 ;
16259 PyObject * obj1 = 0 ;
16260 char *kwnames[] = {
16261 (char *) "self",(char *) "y", NULL
16262 };
16263
16264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
16265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16266 if (SWIG_arg_fail(1)) SWIG_fail;
16267 {
16268 arg2 = (int)(SWIG_As_int(obj1));
16269 if (SWIG_arg_fail(2)) SWIG_fail;
16270 }
16271 {
16272 PyThreadState* __tstate = wxPyBeginAllowThreads();
16273 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
16274
16275 wxPyEndAllowThreads(__tstate);
16276 if (PyErr_Occurred()) SWIG_fail;
16277 }
16278 {
16279 resultobj = SWIG_From_int((int)(result));
16280 }
16281 return resultobj;
16282 fail:
16283 return NULL;
16284 }
16285
16286
16287 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16288 PyObject *resultobj;
16289 wxDC *arg1 = (wxDC *) 0 ;
16290 bool result;
16291 PyObject * obj0 = 0 ;
16292 char *kwnames[] = {
16293 (char *) "self", NULL
16294 };
16295
16296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
16297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16298 if (SWIG_arg_fail(1)) SWIG_fail;
16299 {
16300 PyThreadState* __tstate = wxPyBeginAllowThreads();
16301 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
16302
16303 wxPyEndAllowThreads(__tstate);
16304 if (PyErr_Occurred()) SWIG_fail;
16305 }
16306 {
16307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16308 }
16309 return resultobj;
16310 fail:
16311 return NULL;
16312 }
16313
16314
16315 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
16316 PyObject *resultobj;
16317 wxDC *arg1 = (wxDC *) 0 ;
16318 bool result;
16319 PyObject * obj0 = 0 ;
16320 char *kwnames[] = {
16321 (char *) "self", NULL
16322 };
16323
16324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
16325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16326 if (SWIG_arg_fail(1)) SWIG_fail;
16327 {
16328 PyThreadState* __tstate = wxPyBeginAllowThreads();
16329 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
16330
16331 wxPyEndAllowThreads(__tstate);
16332 if (PyErr_Occurred()) SWIG_fail;
16333 }
16334 {
16335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16336 }
16337 return resultobj;
16338 fail:
16339 return NULL;
16340 }
16341
16342
16343 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
16344 PyObject *resultobj;
16345 wxDC *arg1 = (wxDC *) 0 ;
16346 int result;
16347 PyObject * obj0 = 0 ;
16348 char *kwnames[] = {
16349 (char *) "self", NULL
16350 };
16351
16352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
16353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16354 if (SWIG_arg_fail(1)) SWIG_fail;
16355 {
16356 PyThreadState* __tstate = wxPyBeginAllowThreads();
16357 result = (int)((wxDC const *)arg1)->GetDepth();
16358
16359 wxPyEndAllowThreads(__tstate);
16360 if (PyErr_Occurred()) SWIG_fail;
16361 }
16362 {
16363 resultobj = SWIG_From_int((int)(result));
16364 }
16365 return resultobj;
16366 fail:
16367 return NULL;
16368 }
16369
16370
16371 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
16372 PyObject *resultobj;
16373 wxDC *arg1 = (wxDC *) 0 ;
16374 wxSize result;
16375 PyObject * obj0 = 0 ;
16376 char *kwnames[] = {
16377 (char *) "self", NULL
16378 };
16379
16380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
16381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16382 if (SWIG_arg_fail(1)) SWIG_fail;
16383 {
16384 PyThreadState* __tstate = wxPyBeginAllowThreads();
16385 result = ((wxDC const *)arg1)->GetPPI();
16386
16387 wxPyEndAllowThreads(__tstate);
16388 if (PyErr_Occurred()) SWIG_fail;
16389 }
16390 {
16391 wxSize * resultptr;
16392 resultptr = new wxSize((wxSize &)(result));
16393 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16394 }
16395 return resultobj;
16396 fail:
16397 return NULL;
16398 }
16399
16400
16401 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
16402 PyObject *resultobj;
16403 wxDC *arg1 = (wxDC *) 0 ;
16404 bool result;
16405 PyObject * obj0 = 0 ;
16406 char *kwnames[] = {
16407 (char *) "self", NULL
16408 };
16409
16410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
16411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16412 if (SWIG_arg_fail(1)) SWIG_fail;
16413 {
16414 PyThreadState* __tstate = wxPyBeginAllowThreads();
16415 result = (bool)((wxDC const *)arg1)->Ok();
16416
16417 wxPyEndAllowThreads(__tstate);
16418 if (PyErr_Occurred()) SWIG_fail;
16419 }
16420 {
16421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16422 }
16423 return resultobj;
16424 fail:
16425 return NULL;
16426 }
16427
16428
16429 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
16430 PyObject *resultobj;
16431 wxDC *arg1 = (wxDC *) 0 ;
16432 int result;
16433 PyObject * obj0 = 0 ;
16434 char *kwnames[] = {
16435 (char *) "self", NULL
16436 };
16437
16438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
16439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16440 if (SWIG_arg_fail(1)) SWIG_fail;
16441 {
16442 PyThreadState* __tstate = wxPyBeginAllowThreads();
16443 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
16444
16445 wxPyEndAllowThreads(__tstate);
16446 if (PyErr_Occurred()) SWIG_fail;
16447 }
16448 {
16449 resultobj = SWIG_From_int((int)(result));
16450 }
16451 return resultobj;
16452 fail:
16453 return NULL;
16454 }
16455
16456
16457 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16458 PyObject *resultobj;
16459 wxDC *arg1 = (wxDC *) 0 ;
16460 wxBrush *result;
16461 PyObject * obj0 = 0 ;
16462 char *kwnames[] = {
16463 (char *) "self", NULL
16464 };
16465
16466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
16467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16468 if (SWIG_arg_fail(1)) SWIG_fail;
16469 {
16470 PyThreadState* __tstate = wxPyBeginAllowThreads();
16471 {
16472 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
16473 result = (wxBrush *) &_result_ref;
16474 }
16475
16476 wxPyEndAllowThreads(__tstate);
16477 if (PyErr_Occurred()) SWIG_fail;
16478 }
16479 {
16480 wxBrush* resultptr = new wxBrush(*result);
16481 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
16482 }
16483 return resultobj;
16484 fail:
16485 return NULL;
16486 }
16487
16488
16489 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
16490 PyObject *resultobj;
16491 wxDC *arg1 = (wxDC *) 0 ;
16492 wxBrush *result;
16493 PyObject * obj0 = 0 ;
16494 char *kwnames[] = {
16495 (char *) "self", NULL
16496 };
16497
16498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
16499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16500 if (SWIG_arg_fail(1)) SWIG_fail;
16501 {
16502 PyThreadState* __tstate = wxPyBeginAllowThreads();
16503 {
16504 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
16505 result = (wxBrush *) &_result_ref;
16506 }
16507
16508 wxPyEndAllowThreads(__tstate);
16509 if (PyErr_Occurred()) SWIG_fail;
16510 }
16511 {
16512 wxBrush* resultptr = new wxBrush(*result);
16513 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
16514 }
16515 return resultobj;
16516 fail:
16517 return NULL;
16518 }
16519
16520
16521 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
16522 PyObject *resultobj;
16523 wxDC *arg1 = (wxDC *) 0 ;
16524 wxFont *result;
16525 PyObject * obj0 = 0 ;
16526 char *kwnames[] = {
16527 (char *) "self", NULL
16528 };
16529
16530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
16531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16532 if (SWIG_arg_fail(1)) SWIG_fail;
16533 {
16534 PyThreadState* __tstate = wxPyBeginAllowThreads();
16535 {
16536 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
16537 result = (wxFont *) &_result_ref;
16538 }
16539
16540 wxPyEndAllowThreads(__tstate);
16541 if (PyErr_Occurred()) SWIG_fail;
16542 }
16543 {
16544 wxFont* resultptr = new wxFont(*result);
16545 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
16546 }
16547 return resultobj;
16548 fail:
16549 return NULL;
16550 }
16551
16552
16553 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
16554 PyObject *resultobj;
16555 wxDC *arg1 = (wxDC *) 0 ;
16556 wxPen *result;
16557 PyObject * obj0 = 0 ;
16558 char *kwnames[] = {
16559 (char *) "self", NULL
16560 };
16561
16562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
16563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16564 if (SWIG_arg_fail(1)) SWIG_fail;
16565 {
16566 PyThreadState* __tstate = wxPyBeginAllowThreads();
16567 {
16568 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
16569 result = (wxPen *) &_result_ref;
16570 }
16571
16572 wxPyEndAllowThreads(__tstate);
16573 if (PyErr_Occurred()) SWIG_fail;
16574 }
16575 {
16576 wxPen* resultptr = new wxPen(*result);
16577 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
16578 }
16579 return resultobj;
16580 fail:
16581 return NULL;
16582 }
16583
16584
16585 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16586 PyObject *resultobj;
16587 wxDC *arg1 = (wxDC *) 0 ;
16588 wxColour *result;
16589 PyObject * obj0 = 0 ;
16590 char *kwnames[] = {
16591 (char *) "self", NULL
16592 };
16593
16594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
16595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16596 if (SWIG_arg_fail(1)) SWIG_fail;
16597 {
16598 PyThreadState* __tstate = wxPyBeginAllowThreads();
16599 {
16600 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
16601 result = (wxColour *) &_result_ref;
16602 }
16603
16604 wxPyEndAllowThreads(__tstate);
16605 if (PyErr_Occurred()) SWIG_fail;
16606 }
16607 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16608 return resultobj;
16609 fail:
16610 return NULL;
16611 }
16612
16613
16614 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16615 PyObject *resultobj;
16616 wxDC *arg1 = (wxDC *) 0 ;
16617 wxColour *result;
16618 PyObject * obj0 = 0 ;
16619 char *kwnames[] = {
16620 (char *) "self", NULL
16621 };
16622
16623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",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 {
16629 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
16630 result = (wxColour *) &_result_ref;
16631 }
16632
16633 wxPyEndAllowThreads(__tstate);
16634 if (PyErr_Occurred()) SWIG_fail;
16635 }
16636 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16637 return resultobj;
16638 fail:
16639 return NULL;
16640 }
16641
16642
16643 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16644 PyObject *resultobj;
16645 wxDC *arg1 = (wxDC *) 0 ;
16646 wxColour *arg2 = 0 ;
16647 wxColour temp2 ;
16648 PyObject * obj0 = 0 ;
16649 PyObject * obj1 = 0 ;
16650 char *kwnames[] = {
16651 (char *) "self",(char *) "colour", NULL
16652 };
16653
16654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16656 if (SWIG_arg_fail(1)) SWIG_fail;
16657 {
16658 arg2 = &temp2;
16659 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16660 }
16661 {
16662 PyThreadState* __tstate = wxPyBeginAllowThreads();
16663 (arg1)->SetTextForeground((wxColour const &)*arg2);
16664
16665 wxPyEndAllowThreads(__tstate);
16666 if (PyErr_Occurred()) SWIG_fail;
16667 }
16668 Py_INCREF(Py_None); resultobj = Py_None;
16669 return resultobj;
16670 fail:
16671 return NULL;
16672 }
16673
16674
16675 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16676 PyObject *resultobj;
16677 wxDC *arg1 = (wxDC *) 0 ;
16678 wxColour *arg2 = 0 ;
16679 wxColour temp2 ;
16680 PyObject * obj0 = 0 ;
16681 PyObject * obj1 = 0 ;
16682 char *kwnames[] = {
16683 (char *) "self",(char *) "colour", NULL
16684 };
16685
16686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16688 if (SWIG_arg_fail(1)) SWIG_fail;
16689 {
16690 arg2 = &temp2;
16691 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16692 }
16693 {
16694 PyThreadState* __tstate = wxPyBeginAllowThreads();
16695 (arg1)->SetTextBackground((wxColour const &)*arg2);
16696
16697 wxPyEndAllowThreads(__tstate);
16698 if (PyErr_Occurred()) SWIG_fail;
16699 }
16700 Py_INCREF(Py_None); resultobj = Py_None;
16701 return resultobj;
16702 fail:
16703 return NULL;
16704 }
16705
16706
16707 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16708 PyObject *resultobj;
16709 wxDC *arg1 = (wxDC *) 0 ;
16710 int result;
16711 PyObject * obj0 = 0 ;
16712 char *kwnames[] = {
16713 (char *) "self", NULL
16714 };
16715
16716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16718 if (SWIG_arg_fail(1)) SWIG_fail;
16719 {
16720 PyThreadState* __tstate = wxPyBeginAllowThreads();
16721 result = (int)((wxDC const *)arg1)->GetMapMode();
16722
16723 wxPyEndAllowThreads(__tstate);
16724 if (PyErr_Occurred()) SWIG_fail;
16725 }
16726 {
16727 resultobj = SWIG_From_int((int)(result));
16728 }
16729 return resultobj;
16730 fail:
16731 return NULL;
16732 }
16733
16734
16735 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16736 PyObject *resultobj;
16737 wxDC *arg1 = (wxDC *) 0 ;
16738 int arg2 ;
16739 PyObject * obj0 = 0 ;
16740 PyObject * obj1 = 0 ;
16741 char *kwnames[] = {
16742 (char *) "self",(char *) "mode", NULL
16743 };
16744
16745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16747 if (SWIG_arg_fail(1)) SWIG_fail;
16748 {
16749 arg2 = (int)(SWIG_As_int(obj1));
16750 if (SWIG_arg_fail(2)) SWIG_fail;
16751 }
16752 {
16753 PyThreadState* __tstate = wxPyBeginAllowThreads();
16754 (arg1)->SetMapMode(arg2);
16755
16756 wxPyEndAllowThreads(__tstate);
16757 if (PyErr_Occurred()) SWIG_fail;
16758 }
16759 Py_INCREF(Py_None); resultobj = Py_None;
16760 return resultobj;
16761 fail:
16762 return NULL;
16763 }
16764
16765
16766 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16767 PyObject *resultobj;
16768 wxDC *arg1 = (wxDC *) 0 ;
16769 double *arg2 = (double *) 0 ;
16770 double *arg3 = (double *) 0 ;
16771 double temp2 ;
16772 int res2 = 0 ;
16773 double temp3 ;
16774 int res3 = 0 ;
16775 PyObject * obj0 = 0 ;
16776 char *kwnames[] = {
16777 (char *) "self", NULL
16778 };
16779
16780 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16781 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16784 if (SWIG_arg_fail(1)) SWIG_fail;
16785 {
16786 PyThreadState* __tstate = wxPyBeginAllowThreads();
16787 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16788
16789 wxPyEndAllowThreads(__tstate);
16790 if (PyErr_Occurred()) SWIG_fail;
16791 }
16792 Py_INCREF(Py_None); resultobj = Py_None;
16793 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16794 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16795 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16796 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16797 return resultobj;
16798 fail:
16799 return NULL;
16800 }
16801
16802
16803 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16804 PyObject *resultobj;
16805 wxDC *arg1 = (wxDC *) 0 ;
16806 double arg2 ;
16807 double arg3 ;
16808 PyObject * obj0 = 0 ;
16809 PyObject * obj1 = 0 ;
16810 PyObject * obj2 = 0 ;
16811 char *kwnames[] = {
16812 (char *) "self",(char *) "x",(char *) "y", NULL
16813 };
16814
16815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16817 if (SWIG_arg_fail(1)) SWIG_fail;
16818 {
16819 arg2 = (double)(SWIG_As_double(obj1));
16820 if (SWIG_arg_fail(2)) SWIG_fail;
16821 }
16822 {
16823 arg3 = (double)(SWIG_As_double(obj2));
16824 if (SWIG_arg_fail(3)) SWIG_fail;
16825 }
16826 {
16827 PyThreadState* __tstate = wxPyBeginAllowThreads();
16828 (arg1)->SetUserScale(arg2,arg3);
16829
16830 wxPyEndAllowThreads(__tstate);
16831 if (PyErr_Occurred()) SWIG_fail;
16832 }
16833 Py_INCREF(Py_None); resultobj = Py_None;
16834 return resultobj;
16835 fail:
16836 return NULL;
16837 }
16838
16839
16840 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16841 PyObject *resultobj;
16842 wxDC *arg1 = (wxDC *) 0 ;
16843 double *arg2 = (double *) 0 ;
16844 double *arg3 = (double *) 0 ;
16845 double temp2 ;
16846 int res2 = 0 ;
16847 double temp3 ;
16848 int res3 = 0 ;
16849 PyObject * obj0 = 0 ;
16850 char *kwnames[] = {
16851 (char *) "self", NULL
16852 };
16853
16854 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16855 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16858 if (SWIG_arg_fail(1)) SWIG_fail;
16859 {
16860 PyThreadState* __tstate = wxPyBeginAllowThreads();
16861 (arg1)->GetLogicalScale(arg2,arg3);
16862
16863 wxPyEndAllowThreads(__tstate);
16864 if (PyErr_Occurred()) SWIG_fail;
16865 }
16866 Py_INCREF(Py_None); resultobj = Py_None;
16867 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16868 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16869 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16870 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16871 return resultobj;
16872 fail:
16873 return NULL;
16874 }
16875
16876
16877 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16878 PyObject *resultobj;
16879 wxDC *arg1 = (wxDC *) 0 ;
16880 double arg2 ;
16881 double arg3 ;
16882 PyObject * obj0 = 0 ;
16883 PyObject * obj1 = 0 ;
16884 PyObject * obj2 = 0 ;
16885 char *kwnames[] = {
16886 (char *) "self",(char *) "x",(char *) "y", NULL
16887 };
16888
16889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16891 if (SWIG_arg_fail(1)) SWIG_fail;
16892 {
16893 arg2 = (double)(SWIG_As_double(obj1));
16894 if (SWIG_arg_fail(2)) SWIG_fail;
16895 }
16896 {
16897 arg3 = (double)(SWIG_As_double(obj2));
16898 if (SWIG_arg_fail(3)) SWIG_fail;
16899 }
16900 {
16901 PyThreadState* __tstate = wxPyBeginAllowThreads();
16902 (arg1)->SetLogicalScale(arg2,arg3);
16903
16904 wxPyEndAllowThreads(__tstate);
16905 if (PyErr_Occurred()) SWIG_fail;
16906 }
16907 Py_INCREF(Py_None); resultobj = Py_None;
16908 return resultobj;
16909 fail:
16910 return NULL;
16911 }
16912
16913
16914 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16915 PyObject *resultobj;
16916 wxDC *arg1 = (wxDC *) 0 ;
16917 wxPoint result;
16918 PyObject * obj0 = 0 ;
16919 char *kwnames[] = {
16920 (char *) "self", NULL
16921 };
16922
16923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16925 if (SWIG_arg_fail(1)) SWIG_fail;
16926 {
16927 PyThreadState* __tstate = wxPyBeginAllowThreads();
16928 result = ((wxDC const *)arg1)->GetLogicalOrigin();
16929
16930 wxPyEndAllowThreads(__tstate);
16931 if (PyErr_Occurred()) SWIG_fail;
16932 }
16933 {
16934 wxPoint * resultptr;
16935 resultptr = new wxPoint((wxPoint &)(result));
16936 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16937 }
16938 return resultobj;
16939 fail:
16940 return NULL;
16941 }
16942
16943
16944 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16945 PyObject *resultobj;
16946 wxDC *arg1 = (wxDC *) 0 ;
16947 int *arg2 = (int *) 0 ;
16948 int *arg3 = (int *) 0 ;
16949 int temp2 ;
16950 int res2 = 0 ;
16951 int temp3 ;
16952 int res3 = 0 ;
16953 PyObject * obj0 = 0 ;
16954 char *kwnames[] = {
16955 (char *) "self", NULL
16956 };
16957
16958 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16959 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
16961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16962 if (SWIG_arg_fail(1)) SWIG_fail;
16963 {
16964 PyThreadState* __tstate = wxPyBeginAllowThreads();
16965 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
16966
16967 wxPyEndAllowThreads(__tstate);
16968 if (PyErr_Occurred()) SWIG_fail;
16969 }
16970 Py_INCREF(Py_None); resultobj = Py_None;
16971 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16972 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16973 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16974 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16975 return resultobj;
16976 fail:
16977 return NULL;
16978 }
16979
16980
16981 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16982 PyObject *resultobj;
16983 wxDC *arg1 = (wxDC *) 0 ;
16984 int arg2 ;
16985 int arg3 ;
16986 PyObject * obj0 = 0 ;
16987 PyObject * obj1 = 0 ;
16988 PyObject * obj2 = 0 ;
16989 char *kwnames[] = {
16990 (char *) "self",(char *) "x",(char *) "y", NULL
16991 };
16992
16993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16995 if (SWIG_arg_fail(1)) SWIG_fail;
16996 {
16997 arg2 = (int)(SWIG_As_int(obj1));
16998 if (SWIG_arg_fail(2)) SWIG_fail;
16999 }
17000 {
17001 arg3 = (int)(SWIG_As_int(obj2));
17002 if (SWIG_arg_fail(3)) SWIG_fail;
17003 }
17004 {
17005 PyThreadState* __tstate = wxPyBeginAllowThreads();
17006 (arg1)->SetLogicalOrigin(arg2,arg3);
17007
17008 wxPyEndAllowThreads(__tstate);
17009 if (PyErr_Occurred()) SWIG_fail;
17010 }
17011 Py_INCREF(Py_None); resultobj = Py_None;
17012 return resultobj;
17013 fail:
17014 return NULL;
17015 }
17016
17017
17018 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17019 PyObject *resultobj;
17020 wxDC *arg1 = (wxDC *) 0 ;
17021 wxPoint *arg2 = 0 ;
17022 wxPoint temp2 ;
17023 PyObject * obj0 = 0 ;
17024 PyObject * obj1 = 0 ;
17025 char *kwnames[] = {
17026 (char *) "self",(char *) "point", NULL
17027 };
17028
17029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
17030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17031 if (SWIG_arg_fail(1)) SWIG_fail;
17032 {
17033 arg2 = &temp2;
17034 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17035 }
17036 {
17037 PyThreadState* __tstate = wxPyBeginAllowThreads();
17038 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
17039
17040 wxPyEndAllowThreads(__tstate);
17041 if (PyErr_Occurred()) SWIG_fail;
17042 }
17043 Py_INCREF(Py_None); resultobj = Py_None;
17044 return resultobj;
17045 fail:
17046 return NULL;
17047 }
17048
17049
17050 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17051 PyObject *resultobj;
17052 wxDC *arg1 = (wxDC *) 0 ;
17053 wxPoint result;
17054 PyObject * obj0 = 0 ;
17055 char *kwnames[] = {
17056 (char *) "self", NULL
17057 };
17058
17059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
17060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17061 if (SWIG_arg_fail(1)) SWIG_fail;
17062 {
17063 PyThreadState* __tstate = wxPyBeginAllowThreads();
17064 result = ((wxDC const *)arg1)->GetDeviceOrigin();
17065
17066 wxPyEndAllowThreads(__tstate);
17067 if (PyErr_Occurred()) SWIG_fail;
17068 }
17069 {
17070 wxPoint * resultptr;
17071 resultptr = new wxPoint((wxPoint &)(result));
17072 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17073 }
17074 return resultobj;
17075 fail:
17076 return NULL;
17077 }
17078
17079
17080 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17081 PyObject *resultobj;
17082 wxDC *arg1 = (wxDC *) 0 ;
17083 int *arg2 = (int *) 0 ;
17084 int *arg3 = (int *) 0 ;
17085 int temp2 ;
17086 int res2 = 0 ;
17087 int temp3 ;
17088 int res3 = 0 ;
17089 PyObject * obj0 = 0 ;
17090 char *kwnames[] = {
17091 (char *) "self", NULL
17092 };
17093
17094 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17095 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
17097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17098 if (SWIG_arg_fail(1)) SWIG_fail;
17099 {
17100 PyThreadState* __tstate = wxPyBeginAllowThreads();
17101 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
17102
17103 wxPyEndAllowThreads(__tstate);
17104 if (PyErr_Occurred()) SWIG_fail;
17105 }
17106 Py_INCREF(Py_None); resultobj = Py_None;
17107 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17108 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17109 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17110 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17111 return resultobj;
17112 fail:
17113 return NULL;
17114 }
17115
17116
17117 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17118 PyObject *resultobj;
17119 wxDC *arg1 = (wxDC *) 0 ;
17120 int arg2 ;
17121 int arg3 ;
17122 PyObject * obj0 = 0 ;
17123 PyObject * obj1 = 0 ;
17124 PyObject * obj2 = 0 ;
17125 char *kwnames[] = {
17126 (char *) "self",(char *) "x",(char *) "y", NULL
17127 };
17128
17129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
17130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17131 if (SWIG_arg_fail(1)) SWIG_fail;
17132 {
17133 arg2 = (int)(SWIG_As_int(obj1));
17134 if (SWIG_arg_fail(2)) SWIG_fail;
17135 }
17136 {
17137 arg3 = (int)(SWIG_As_int(obj2));
17138 if (SWIG_arg_fail(3)) SWIG_fail;
17139 }
17140 {
17141 PyThreadState* __tstate = wxPyBeginAllowThreads();
17142 (arg1)->SetDeviceOrigin(arg2,arg3);
17143
17144 wxPyEndAllowThreads(__tstate);
17145 if (PyErr_Occurred()) SWIG_fail;
17146 }
17147 Py_INCREF(Py_None); resultobj = Py_None;
17148 return resultobj;
17149 fail:
17150 return NULL;
17151 }
17152
17153
17154 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17155 PyObject *resultobj;
17156 wxDC *arg1 = (wxDC *) 0 ;
17157 wxPoint *arg2 = 0 ;
17158 wxPoint temp2 ;
17159 PyObject * obj0 = 0 ;
17160 PyObject * obj1 = 0 ;
17161 char *kwnames[] = {
17162 (char *) "self",(char *) "point", NULL
17163 };
17164
17165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
17166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17167 if (SWIG_arg_fail(1)) SWIG_fail;
17168 {
17169 arg2 = &temp2;
17170 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17171 }
17172 {
17173 PyThreadState* __tstate = wxPyBeginAllowThreads();
17174 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
17175
17176 wxPyEndAllowThreads(__tstate);
17177 if (PyErr_Occurred()) SWIG_fail;
17178 }
17179 Py_INCREF(Py_None); resultobj = Py_None;
17180 return resultobj;
17181 fail:
17182 return NULL;
17183 }
17184
17185
17186 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17187 PyObject *resultobj;
17188 wxDC *arg1 = (wxDC *) 0 ;
17189 bool arg2 ;
17190 bool arg3 ;
17191 PyObject * obj0 = 0 ;
17192 PyObject * obj1 = 0 ;
17193 PyObject * obj2 = 0 ;
17194 char *kwnames[] = {
17195 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
17196 };
17197
17198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
17199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17200 if (SWIG_arg_fail(1)) SWIG_fail;
17201 {
17202 arg2 = (bool)(SWIG_As_bool(obj1));
17203 if (SWIG_arg_fail(2)) SWIG_fail;
17204 }
17205 {
17206 arg3 = (bool)(SWIG_As_bool(obj2));
17207 if (SWIG_arg_fail(3)) SWIG_fail;
17208 }
17209 {
17210 PyThreadState* __tstate = wxPyBeginAllowThreads();
17211 (arg1)->SetAxisOrientation(arg2,arg3);
17212
17213 wxPyEndAllowThreads(__tstate);
17214 if (PyErr_Occurred()) SWIG_fail;
17215 }
17216 Py_INCREF(Py_None); resultobj = Py_None;
17217 return resultobj;
17218 fail:
17219 return NULL;
17220 }
17221
17222
17223 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
17224 PyObject *resultobj;
17225 wxDC *arg1 = (wxDC *) 0 ;
17226 int result;
17227 PyObject * obj0 = 0 ;
17228 char *kwnames[] = {
17229 (char *) "self", NULL
17230 };
17231
17232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
17233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17234 if (SWIG_arg_fail(1)) SWIG_fail;
17235 {
17236 PyThreadState* __tstate = wxPyBeginAllowThreads();
17237 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
17238
17239 wxPyEndAllowThreads(__tstate);
17240 if (PyErr_Occurred()) SWIG_fail;
17241 }
17242 {
17243 resultobj = SWIG_From_int((int)(result));
17244 }
17245 return resultobj;
17246 fail:
17247 return NULL;
17248 }
17249
17250
17251 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
17252 PyObject *resultobj;
17253 wxDC *arg1 = (wxDC *) 0 ;
17254 int arg2 ;
17255 PyObject * obj0 = 0 ;
17256 PyObject * obj1 = 0 ;
17257 char *kwnames[] = {
17258 (char *) "self",(char *) "function", NULL
17259 };
17260
17261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
17262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17263 if (SWIG_arg_fail(1)) SWIG_fail;
17264 {
17265 arg2 = (int)(SWIG_As_int(obj1));
17266 if (SWIG_arg_fail(2)) SWIG_fail;
17267 }
17268 {
17269 PyThreadState* __tstate = wxPyBeginAllowThreads();
17270 (arg1)->SetLogicalFunction(arg2);
17271
17272 wxPyEndAllowThreads(__tstate);
17273 if (PyErr_Occurred()) SWIG_fail;
17274 }
17275 Py_INCREF(Py_None); resultobj = Py_None;
17276 return resultobj;
17277 fail:
17278 return NULL;
17279 }
17280
17281
17282 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17283 PyObject *resultobj;
17284 wxDC *arg1 = (wxDC *) 0 ;
17285 PyObject * obj0 = 0 ;
17286 char *kwnames[] = {
17287 (char *) "self", NULL
17288 };
17289
17290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
17291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17292 if (SWIG_arg_fail(1)) SWIG_fail;
17293 {
17294 PyThreadState* __tstate = wxPyBeginAllowThreads();
17295 (arg1)->ComputeScaleAndOrigin();
17296
17297 wxPyEndAllowThreads(__tstate);
17298 if (PyErr_Occurred()) SWIG_fail;
17299 }
17300 Py_INCREF(Py_None); resultobj = Py_None;
17301 return resultobj;
17302 fail:
17303 return NULL;
17304 }
17305
17306
17307 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17308 PyObject *resultobj;
17309 wxDC *arg1 = (wxDC *) 0 ;
17310 int arg2 ;
17311 int arg3 ;
17312 PyObject * obj0 = 0 ;
17313 PyObject * obj1 = 0 ;
17314 PyObject * obj2 = 0 ;
17315 char *kwnames[] = {
17316 (char *) "self",(char *) "x",(char *) "y", NULL
17317 };
17318
17319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
17320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17321 if (SWIG_arg_fail(1)) SWIG_fail;
17322 {
17323 arg2 = (int)(SWIG_As_int(obj1));
17324 if (SWIG_arg_fail(2)) SWIG_fail;
17325 }
17326 {
17327 arg3 = (int)(SWIG_As_int(obj2));
17328 if (SWIG_arg_fail(3)) SWIG_fail;
17329 }
17330 {
17331 PyThreadState* __tstate = wxPyBeginAllowThreads();
17332 (arg1)->CalcBoundingBox(arg2,arg3);
17333
17334 wxPyEndAllowThreads(__tstate);
17335 if (PyErr_Occurred()) SWIG_fail;
17336 }
17337 Py_INCREF(Py_None); resultobj = Py_None;
17338 return resultobj;
17339 fail:
17340 return NULL;
17341 }
17342
17343
17344 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17345 PyObject *resultobj;
17346 wxDC *arg1 = (wxDC *) 0 ;
17347 wxPoint *arg2 = 0 ;
17348 wxPoint temp2 ;
17349 PyObject * obj0 = 0 ;
17350 PyObject * obj1 = 0 ;
17351 char *kwnames[] = {
17352 (char *) "self",(char *) "point", NULL
17353 };
17354
17355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
17356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17357 if (SWIG_arg_fail(1)) SWIG_fail;
17358 {
17359 arg2 = &temp2;
17360 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17361 }
17362 {
17363 PyThreadState* __tstate = wxPyBeginAllowThreads();
17364 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
17365
17366 wxPyEndAllowThreads(__tstate);
17367 if (PyErr_Occurred()) SWIG_fail;
17368 }
17369 Py_INCREF(Py_None); resultobj = Py_None;
17370 return resultobj;
17371 fail:
17372 return NULL;
17373 }
17374
17375
17376 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17377 PyObject *resultobj;
17378 wxDC *arg1 = (wxDC *) 0 ;
17379 PyObject * obj0 = 0 ;
17380 char *kwnames[] = {
17381 (char *) "self", NULL
17382 };
17383
17384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
17385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17386 if (SWIG_arg_fail(1)) SWIG_fail;
17387 {
17388 PyThreadState* __tstate = wxPyBeginAllowThreads();
17389 (arg1)->ResetBoundingBox();
17390
17391 wxPyEndAllowThreads(__tstate);
17392 if (PyErr_Occurred()) SWIG_fail;
17393 }
17394 Py_INCREF(Py_None); resultobj = Py_None;
17395 return resultobj;
17396 fail:
17397 return NULL;
17398 }
17399
17400
17401 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
17402 PyObject *resultobj;
17403 wxDC *arg1 = (wxDC *) 0 ;
17404 int result;
17405 PyObject * obj0 = 0 ;
17406 char *kwnames[] = {
17407 (char *) "self", NULL
17408 };
17409
17410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
17411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17412 if (SWIG_arg_fail(1)) SWIG_fail;
17413 {
17414 PyThreadState* __tstate = wxPyBeginAllowThreads();
17415 result = (int)((wxDC const *)arg1)->MinX();
17416
17417 wxPyEndAllowThreads(__tstate);
17418 if (PyErr_Occurred()) SWIG_fail;
17419 }
17420 {
17421 resultobj = SWIG_From_int((int)(result));
17422 }
17423 return resultobj;
17424 fail:
17425 return NULL;
17426 }
17427
17428
17429 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
17430 PyObject *resultobj;
17431 wxDC *arg1 = (wxDC *) 0 ;
17432 int result;
17433 PyObject * obj0 = 0 ;
17434 char *kwnames[] = {
17435 (char *) "self", NULL
17436 };
17437
17438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
17439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17440 if (SWIG_arg_fail(1)) SWIG_fail;
17441 {
17442 PyThreadState* __tstate = wxPyBeginAllowThreads();
17443 result = (int)((wxDC const *)arg1)->MaxX();
17444
17445 wxPyEndAllowThreads(__tstate);
17446 if (PyErr_Occurred()) SWIG_fail;
17447 }
17448 {
17449 resultobj = SWIG_From_int((int)(result));
17450 }
17451 return resultobj;
17452 fail:
17453 return NULL;
17454 }
17455
17456
17457 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
17458 PyObject *resultobj;
17459 wxDC *arg1 = (wxDC *) 0 ;
17460 int result;
17461 PyObject * obj0 = 0 ;
17462 char *kwnames[] = {
17463 (char *) "self", NULL
17464 };
17465
17466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
17467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17468 if (SWIG_arg_fail(1)) SWIG_fail;
17469 {
17470 PyThreadState* __tstate = wxPyBeginAllowThreads();
17471 result = (int)((wxDC const *)arg1)->MinY();
17472
17473 wxPyEndAllowThreads(__tstate);
17474 if (PyErr_Occurred()) SWIG_fail;
17475 }
17476 {
17477 resultobj = SWIG_From_int((int)(result));
17478 }
17479 return resultobj;
17480 fail:
17481 return NULL;
17482 }
17483
17484
17485 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
17486 PyObject *resultobj;
17487 wxDC *arg1 = (wxDC *) 0 ;
17488 int result;
17489 PyObject * obj0 = 0 ;
17490 char *kwnames[] = {
17491 (char *) "self", NULL
17492 };
17493
17494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
17495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17496 if (SWIG_arg_fail(1)) SWIG_fail;
17497 {
17498 PyThreadState* __tstate = wxPyBeginAllowThreads();
17499 result = (int)((wxDC const *)arg1)->MaxY();
17500
17501 wxPyEndAllowThreads(__tstate);
17502 if (PyErr_Occurred()) SWIG_fail;
17503 }
17504 {
17505 resultobj = SWIG_From_int((int)(result));
17506 }
17507 return resultobj;
17508 fail:
17509 return NULL;
17510 }
17511
17512
17513 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17514 PyObject *resultobj;
17515 wxDC *arg1 = (wxDC *) 0 ;
17516 int *arg2 = (int *) 0 ;
17517 int *arg3 = (int *) 0 ;
17518 int *arg4 = (int *) 0 ;
17519 int *arg5 = (int *) 0 ;
17520 int temp2 ;
17521 int res2 = 0 ;
17522 int temp3 ;
17523 int res3 = 0 ;
17524 int temp4 ;
17525 int res4 = 0 ;
17526 int temp5 ;
17527 int res5 = 0 ;
17528 PyObject * obj0 = 0 ;
17529 char *kwnames[] = {
17530 (char *) "self", NULL
17531 };
17532
17533 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17534 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17535 arg4 = &temp4; res4 = SWIG_NEWOBJ;
17536 arg5 = &temp5; res5 = SWIG_NEWOBJ;
17537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
17538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17539 if (SWIG_arg_fail(1)) SWIG_fail;
17540 {
17541 PyThreadState* __tstate = wxPyBeginAllowThreads();
17542 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
17543
17544 wxPyEndAllowThreads(__tstate);
17545 if (PyErr_Occurred()) SWIG_fail;
17546 }
17547 Py_INCREF(Py_None); resultobj = Py_None;
17548 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17549 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17550 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17551 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17552 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
17553 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
17554 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
17555 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
17556 return resultobj;
17557 fail:
17558 return NULL;
17559 }
17560
17561
17562 static PyObject *_wrap_DC_GetHDC(PyObject *, PyObject *args, PyObject *kwargs) {
17563 PyObject *resultobj;
17564 wxDC *arg1 = (wxDC *) 0 ;
17565 long result;
17566 PyObject * obj0 = 0 ;
17567 char *kwnames[] = {
17568 (char *) "self", NULL
17569 };
17570
17571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetHDC",kwnames,&obj0)) goto fail;
17572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17573 if (SWIG_arg_fail(1)) SWIG_fail;
17574 {
17575 PyThreadState* __tstate = wxPyBeginAllowThreads();
17576 result = (long)(arg1)->GetHDC();
17577
17578 wxPyEndAllowThreads(__tstate);
17579 if (PyErr_Occurred()) SWIG_fail;
17580 }
17581 {
17582 resultobj = SWIG_From_long((long)(result));
17583 }
17584 return resultobj;
17585 fail:
17586 return NULL;
17587 }
17588
17589
17590 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
17591 PyObject *resultobj;
17592 wxDC *arg1 = (wxDC *) 0 ;
17593 PyObject *arg2 = (PyObject *) 0 ;
17594 PyObject *arg3 = (PyObject *) 0 ;
17595 PyObject *arg4 = (PyObject *) 0 ;
17596 PyObject *result;
17597 PyObject * obj0 = 0 ;
17598 PyObject * obj1 = 0 ;
17599 PyObject * obj2 = 0 ;
17600 PyObject * obj3 = 0 ;
17601 char *kwnames[] = {
17602 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17603 };
17604
17605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17607 if (SWIG_arg_fail(1)) SWIG_fail;
17608 arg2 = obj1;
17609 arg3 = obj2;
17610 arg4 = obj3;
17611 {
17612 PyThreadState* __tstate = wxPyBeginAllowThreads();
17613 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
17614
17615 wxPyEndAllowThreads(__tstate);
17616 if (PyErr_Occurred()) SWIG_fail;
17617 }
17618 resultobj = result;
17619 return resultobj;
17620 fail:
17621 return NULL;
17622 }
17623
17624
17625 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
17626 PyObject *resultobj;
17627 wxDC *arg1 = (wxDC *) 0 ;
17628 PyObject *arg2 = (PyObject *) 0 ;
17629 PyObject *arg3 = (PyObject *) 0 ;
17630 PyObject *arg4 = (PyObject *) 0 ;
17631 PyObject *result;
17632 PyObject * obj0 = 0 ;
17633 PyObject * obj1 = 0 ;
17634 PyObject * obj2 = 0 ;
17635 PyObject * obj3 = 0 ;
17636 char *kwnames[] = {
17637 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17638 };
17639
17640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17642 if (SWIG_arg_fail(1)) SWIG_fail;
17643 arg2 = obj1;
17644 arg3 = obj2;
17645 arg4 = obj3;
17646 {
17647 PyThreadState* __tstate = wxPyBeginAllowThreads();
17648 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
17649
17650 wxPyEndAllowThreads(__tstate);
17651 if (PyErr_Occurred()) SWIG_fail;
17652 }
17653 resultobj = result;
17654 return resultobj;
17655 fail:
17656 return NULL;
17657 }
17658
17659
17660 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
17661 PyObject *resultobj;
17662 wxDC *arg1 = (wxDC *) 0 ;
17663 PyObject *arg2 = (PyObject *) 0 ;
17664 PyObject *arg3 = (PyObject *) 0 ;
17665 PyObject *arg4 = (PyObject *) 0 ;
17666 PyObject *result;
17667 PyObject * obj0 = 0 ;
17668 PyObject * obj1 = 0 ;
17669 PyObject * obj2 = 0 ;
17670 PyObject * obj3 = 0 ;
17671 char *kwnames[] = {
17672 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17673 };
17674
17675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17677 if (SWIG_arg_fail(1)) SWIG_fail;
17678 arg2 = obj1;
17679 arg3 = obj2;
17680 arg4 = obj3;
17681 {
17682 PyThreadState* __tstate = wxPyBeginAllowThreads();
17683 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17684
17685 wxPyEndAllowThreads(__tstate);
17686 if (PyErr_Occurred()) SWIG_fail;
17687 }
17688 resultobj = result;
17689 return resultobj;
17690 fail:
17691 return NULL;
17692 }
17693
17694
17695 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17696 PyObject *resultobj;
17697 wxDC *arg1 = (wxDC *) 0 ;
17698 PyObject *arg2 = (PyObject *) 0 ;
17699 PyObject *arg3 = (PyObject *) 0 ;
17700 PyObject *arg4 = (PyObject *) 0 ;
17701 PyObject *result;
17702 PyObject * obj0 = 0 ;
17703 PyObject * obj1 = 0 ;
17704 PyObject * obj2 = 0 ;
17705 PyObject * obj3 = 0 ;
17706 char *kwnames[] = {
17707 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17708 };
17709
17710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17712 if (SWIG_arg_fail(1)) SWIG_fail;
17713 arg2 = obj1;
17714 arg3 = obj2;
17715 arg4 = obj3;
17716 {
17717 PyThreadState* __tstate = wxPyBeginAllowThreads();
17718 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17719
17720 wxPyEndAllowThreads(__tstate);
17721 if (PyErr_Occurred()) SWIG_fail;
17722 }
17723 resultobj = result;
17724 return resultobj;
17725 fail:
17726 return NULL;
17727 }
17728
17729
17730 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17731 PyObject *resultobj;
17732 wxDC *arg1 = (wxDC *) 0 ;
17733 PyObject *arg2 = (PyObject *) 0 ;
17734 PyObject *arg3 = (PyObject *) 0 ;
17735 PyObject *arg4 = (PyObject *) 0 ;
17736 PyObject *result;
17737 PyObject * obj0 = 0 ;
17738 PyObject * obj1 = 0 ;
17739 PyObject * obj2 = 0 ;
17740 PyObject * obj3 = 0 ;
17741 char *kwnames[] = {
17742 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17743 };
17744
17745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17747 if (SWIG_arg_fail(1)) SWIG_fail;
17748 arg2 = obj1;
17749 arg3 = obj2;
17750 arg4 = obj3;
17751 {
17752 PyThreadState* __tstate = wxPyBeginAllowThreads();
17753 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17754
17755 wxPyEndAllowThreads(__tstate);
17756 if (PyErr_Occurred()) SWIG_fail;
17757 }
17758 resultobj = result;
17759 return resultobj;
17760 fail:
17761 return NULL;
17762 }
17763
17764
17765 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17766 PyObject *resultobj;
17767 wxDC *arg1 = (wxDC *) 0 ;
17768 PyObject *arg2 = (PyObject *) 0 ;
17769 PyObject *arg3 = (PyObject *) 0 ;
17770 PyObject *arg4 = (PyObject *) 0 ;
17771 PyObject *arg5 = (PyObject *) 0 ;
17772 PyObject *result;
17773 PyObject * obj0 = 0 ;
17774 PyObject * obj1 = 0 ;
17775 PyObject * obj2 = 0 ;
17776 PyObject * obj3 = 0 ;
17777 PyObject * obj4 = 0 ;
17778 char *kwnames[] = {
17779 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17780 };
17781
17782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17784 if (SWIG_arg_fail(1)) SWIG_fail;
17785 arg2 = obj1;
17786 arg3 = obj2;
17787 arg4 = obj3;
17788 arg5 = obj4;
17789 {
17790 PyThreadState* __tstate = wxPyBeginAllowThreads();
17791 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17792
17793 wxPyEndAllowThreads(__tstate);
17794 if (PyErr_Occurred()) SWIG_fail;
17795 }
17796 resultobj = result;
17797 return resultobj;
17798 fail:
17799 return NULL;
17800 }
17801
17802
17803 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17804 PyObject *obj;
17805 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17806 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17807 Py_INCREF(obj);
17808 return Py_BuildValue((char *)"");
17809 }
17810 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17811 PyObject *resultobj;
17812 wxMemoryDC *result;
17813 char *kwnames[] = {
17814 NULL
17815 };
17816
17817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17818 {
17819 if (!wxPyCheckForApp()) SWIG_fail;
17820 PyThreadState* __tstate = wxPyBeginAllowThreads();
17821 result = (wxMemoryDC *)new wxMemoryDC();
17822
17823 wxPyEndAllowThreads(__tstate);
17824 if (PyErr_Occurred()) SWIG_fail;
17825 }
17826 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17827 return resultobj;
17828 fail:
17829 return NULL;
17830 }
17831
17832
17833 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17834 PyObject *resultobj;
17835 wxDC *arg1 = (wxDC *) 0 ;
17836 wxMemoryDC *result;
17837 PyObject * obj0 = 0 ;
17838 char *kwnames[] = {
17839 (char *) "oldDC", NULL
17840 };
17841
17842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17844 if (SWIG_arg_fail(1)) SWIG_fail;
17845 {
17846 if (!wxPyCheckForApp()) SWIG_fail;
17847 PyThreadState* __tstate = wxPyBeginAllowThreads();
17848 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17849
17850 wxPyEndAllowThreads(__tstate);
17851 if (PyErr_Occurred()) SWIG_fail;
17852 }
17853 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17854 return resultobj;
17855 fail:
17856 return NULL;
17857 }
17858
17859
17860 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17861 PyObject *resultobj;
17862 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17863 wxBitmap *arg2 = 0 ;
17864 PyObject * obj0 = 0 ;
17865 PyObject * obj1 = 0 ;
17866 char *kwnames[] = {
17867 (char *) "self",(char *) "bitmap", NULL
17868 };
17869
17870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17872 if (SWIG_arg_fail(1)) SWIG_fail;
17873 {
17874 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17875 if (SWIG_arg_fail(2)) SWIG_fail;
17876 if (arg2 == NULL) {
17877 SWIG_null_ref("wxBitmap");
17878 }
17879 if (SWIG_arg_fail(2)) SWIG_fail;
17880 }
17881 {
17882 PyThreadState* __tstate = wxPyBeginAllowThreads();
17883 (arg1)->SelectObject((wxBitmap const &)*arg2);
17884
17885 wxPyEndAllowThreads(__tstate);
17886 if (PyErr_Occurred()) SWIG_fail;
17887 }
17888 Py_INCREF(Py_None); resultobj = Py_None;
17889 return resultobj;
17890 fail:
17891 return NULL;
17892 }
17893
17894
17895 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17896 PyObject *obj;
17897 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17898 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17899 Py_INCREF(obj);
17900 return Py_BuildValue((char *)"");
17901 }
17902 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17903 PyObject *resultobj;
17904 wxDC *arg1 = (wxDC *) 0 ;
17905 wxBitmap *arg2 = 0 ;
17906 wxBufferedDC *result;
17907 PyObject * obj0 = 0 ;
17908 PyObject * obj1 = 0 ;
17909
17910 if(!PyArg_ParseTuple(args,(char *)"OO:new_BufferedDC",&obj0,&obj1)) goto fail;
17911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17912 if (SWIG_arg_fail(1)) SWIG_fail;
17913 {
17914 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17915 if (SWIG_arg_fail(2)) SWIG_fail;
17916 if (arg2 == NULL) {
17917 SWIG_null_ref("wxBitmap");
17918 }
17919 if (SWIG_arg_fail(2)) SWIG_fail;
17920 }
17921 {
17922 if (!wxPyCheckForApp()) SWIG_fail;
17923 PyThreadState* __tstate = wxPyBeginAllowThreads();
17924 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2);
17925
17926 wxPyEndAllowThreads(__tstate);
17927 if (PyErr_Occurred()) SWIG_fail;
17928 }
17929 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17930 return resultobj;
17931 fail:
17932 return NULL;
17933 }
17934
17935
17936 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17937 PyObject *resultobj;
17938 wxDC *arg1 = (wxDC *) 0 ;
17939 wxSize *arg2 = 0 ;
17940 wxBufferedDC *result;
17941 wxSize temp2 ;
17942 PyObject * obj0 = 0 ;
17943 PyObject * obj1 = 0 ;
17944
17945 if(!PyArg_ParseTuple(args,(char *)"OO:new_BufferedDC",&obj0,&obj1)) goto fail;
17946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17947 if (SWIG_arg_fail(1)) SWIG_fail;
17948 {
17949 arg2 = &temp2;
17950 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17951 }
17952 {
17953 if (!wxPyCheckForApp()) SWIG_fail;
17954 PyThreadState* __tstate = wxPyBeginAllowThreads();
17955 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2);
17956
17957 wxPyEndAllowThreads(__tstate);
17958 if (PyErr_Occurred()) SWIG_fail;
17959 }
17960 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17961 return resultobj;
17962 fail:
17963 return NULL;
17964 }
17965
17966
17967 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
17968 int argc;
17969 PyObject *argv[3];
17970 int ii;
17971
17972 argc = PyObject_Length(args);
17973 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
17974 argv[ii] = PyTuple_GetItem(args,ii);
17975 }
17976 if (argc == 2) {
17977 int _v;
17978 {
17979 void *ptr;
17980 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17981 _v = 0;
17982 PyErr_Clear();
17983 } else {
17984 _v = 1;
17985 }
17986 }
17987 if (_v) {
17988 {
17989 void *ptr = 0;
17990 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
17991 _v = 0;
17992 PyErr_Clear();
17993 } else {
17994 _v = (ptr != 0);
17995 }
17996 }
17997 if (_v) {
17998 return _wrap_new_BufferedDC__SWIG_0(self,args);
17999 }
18000 }
18001 }
18002 if (argc == 2) {
18003 int _v;
18004 {
18005 void *ptr;
18006 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
18007 _v = 0;
18008 PyErr_Clear();
18009 } else {
18010 _v = 1;
18011 }
18012 }
18013 if (_v) {
18014 {
18015 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
18016 }
18017 if (_v) {
18018 return _wrap_new_BufferedDC__SWIG_1(self,args);
18019 }
18020 }
18021 }
18022
18023 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
18024 return NULL;
18025 }
18026
18027
18028 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
18029 PyObject *resultobj;
18030 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
18031 PyObject * obj0 = 0 ;
18032 char *kwnames[] = {
18033 (char *) "self", NULL
18034 };
18035
18036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
18037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
18038 if (SWIG_arg_fail(1)) SWIG_fail;
18039 {
18040 PyThreadState* __tstate = wxPyBeginAllowThreads();
18041 delete arg1;
18042
18043 wxPyEndAllowThreads(__tstate);
18044 if (PyErr_Occurred()) SWIG_fail;
18045 }
18046 Py_INCREF(Py_None); resultobj = Py_None;
18047 return resultobj;
18048 fail:
18049 return NULL;
18050 }
18051
18052
18053 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
18054 PyObject *resultobj;
18055 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
18056 PyObject * obj0 = 0 ;
18057 char *kwnames[] = {
18058 (char *) "self", NULL
18059 };
18060
18061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
18062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
18063 if (SWIG_arg_fail(1)) SWIG_fail;
18064 {
18065 PyThreadState* __tstate = wxPyBeginAllowThreads();
18066 (arg1)->UnMask();
18067
18068 wxPyEndAllowThreads(__tstate);
18069 if (PyErr_Occurred()) SWIG_fail;
18070 }
18071 Py_INCREF(Py_None); resultobj = Py_None;
18072 return resultobj;
18073 fail:
18074 return NULL;
18075 }
18076
18077
18078 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
18079 PyObject *obj;
18080 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18081 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
18082 Py_INCREF(obj);
18083 return Py_BuildValue((char *)"");
18084 }
18085 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
18086 PyObject *resultobj;
18087 wxWindow *arg1 = (wxWindow *) 0 ;
18088 wxBitmap const &arg2_defvalue = wxNullBitmap ;
18089 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
18090 wxBufferedPaintDC *result;
18091 PyObject * obj0 = 0 ;
18092 PyObject * obj1 = 0 ;
18093 char *kwnames[] = {
18094 (char *) "window",(char *) "buffer", NULL
18095 };
18096
18097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BufferedPaintDC",kwnames,&obj0,&obj1)) goto fail;
18098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18099 if (SWIG_arg_fail(1)) SWIG_fail;
18100 if (obj1) {
18101 {
18102 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18103 if (SWIG_arg_fail(2)) SWIG_fail;
18104 if (arg2 == NULL) {
18105 SWIG_null_ref("wxBitmap");
18106 }
18107 if (SWIG_arg_fail(2)) SWIG_fail;
18108 }
18109 }
18110 {
18111 if (!wxPyCheckForApp()) SWIG_fail;
18112 PyThreadState* __tstate = wxPyBeginAllowThreads();
18113 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2);
18114
18115 wxPyEndAllowThreads(__tstate);
18116 if (PyErr_Occurred()) SWIG_fail;
18117 }
18118 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
18119 return resultobj;
18120 fail:
18121 return NULL;
18122 }
18123
18124
18125 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
18126 PyObject *obj;
18127 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18128 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
18129 Py_INCREF(obj);
18130 return Py_BuildValue((char *)"");
18131 }
18132 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
18133 PyObject *resultobj;
18134 wxScreenDC *result;
18135 char *kwnames[] = {
18136 NULL
18137 };
18138
18139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
18140 {
18141 if (!wxPyCheckForApp()) SWIG_fail;
18142 PyThreadState* __tstate = wxPyBeginAllowThreads();
18143 result = (wxScreenDC *)new wxScreenDC();
18144
18145 wxPyEndAllowThreads(__tstate);
18146 if (PyErr_Occurred()) SWIG_fail;
18147 }
18148 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
18149 return resultobj;
18150 fail:
18151 return NULL;
18152 }
18153
18154
18155 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
18156 PyObject *resultobj;
18157 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18158 wxWindow *arg2 = (wxWindow *) 0 ;
18159 bool result;
18160 PyObject * obj0 = 0 ;
18161 PyObject * obj1 = 0 ;
18162 char *kwnames[] = {
18163 (char *) "self",(char *) "window", NULL
18164 };
18165
18166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
18167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18168 if (SWIG_arg_fail(1)) SWIG_fail;
18169 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18170 if (SWIG_arg_fail(2)) SWIG_fail;
18171 {
18172 PyThreadState* __tstate = wxPyBeginAllowThreads();
18173 result = (bool)(arg1)->StartDrawingOnTop(arg2);
18174
18175 wxPyEndAllowThreads(__tstate);
18176 if (PyErr_Occurred()) SWIG_fail;
18177 }
18178 {
18179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18180 }
18181 return resultobj;
18182 fail:
18183 return NULL;
18184 }
18185
18186
18187 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
18188 PyObject *resultobj;
18189 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18190 wxRect *arg2 = (wxRect *) NULL ;
18191 bool result;
18192 PyObject * obj0 = 0 ;
18193 PyObject * obj1 = 0 ;
18194 char *kwnames[] = {
18195 (char *) "self",(char *) "rect", NULL
18196 };
18197
18198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
18199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18200 if (SWIG_arg_fail(1)) SWIG_fail;
18201 if (obj1) {
18202 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18203 if (SWIG_arg_fail(2)) SWIG_fail;
18204 }
18205 {
18206 PyThreadState* __tstate = wxPyBeginAllowThreads();
18207 result = (bool)(arg1)->StartDrawingOnTop(arg2);
18208
18209 wxPyEndAllowThreads(__tstate);
18210 if (PyErr_Occurred()) SWIG_fail;
18211 }
18212 {
18213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18214 }
18215 return resultobj;
18216 fail:
18217 return NULL;
18218 }
18219
18220
18221 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
18222 PyObject *resultobj;
18223 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18224 bool result;
18225 PyObject * obj0 = 0 ;
18226 char *kwnames[] = {
18227 (char *) "self", NULL
18228 };
18229
18230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
18231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18232 if (SWIG_arg_fail(1)) SWIG_fail;
18233 {
18234 PyThreadState* __tstate = wxPyBeginAllowThreads();
18235 result = (bool)(arg1)->EndDrawingOnTop();
18236
18237 wxPyEndAllowThreads(__tstate);
18238 if (PyErr_Occurred()) SWIG_fail;
18239 }
18240 {
18241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18242 }
18243 return resultobj;
18244 fail:
18245 return NULL;
18246 }
18247
18248
18249 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
18250 PyObject *obj;
18251 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18252 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
18253 Py_INCREF(obj);
18254 return Py_BuildValue((char *)"");
18255 }
18256 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
18257 PyObject *resultobj;
18258 wxWindow *arg1 = (wxWindow *) 0 ;
18259 wxClientDC *result;
18260 PyObject * obj0 = 0 ;
18261 char *kwnames[] = {
18262 (char *) "win", NULL
18263 };
18264
18265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
18266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18267 if (SWIG_arg_fail(1)) SWIG_fail;
18268 {
18269 if (!wxPyCheckForApp()) SWIG_fail;
18270 PyThreadState* __tstate = wxPyBeginAllowThreads();
18271 result = (wxClientDC *)new wxClientDC(arg1);
18272
18273 wxPyEndAllowThreads(__tstate);
18274 if (PyErr_Occurred()) SWIG_fail;
18275 }
18276 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
18277 return resultobj;
18278 fail:
18279 return NULL;
18280 }
18281
18282
18283 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
18284 PyObject *obj;
18285 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18286 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
18287 Py_INCREF(obj);
18288 return Py_BuildValue((char *)"");
18289 }
18290 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
18291 PyObject *resultobj;
18292 wxWindow *arg1 = (wxWindow *) 0 ;
18293 wxPaintDC *result;
18294 PyObject * obj0 = 0 ;
18295 char *kwnames[] = {
18296 (char *) "win", NULL
18297 };
18298
18299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
18300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18301 if (SWIG_arg_fail(1)) SWIG_fail;
18302 {
18303 if (!wxPyCheckForApp()) SWIG_fail;
18304 PyThreadState* __tstate = wxPyBeginAllowThreads();
18305 result = (wxPaintDC *)new wxPaintDC(arg1);
18306
18307 wxPyEndAllowThreads(__tstate);
18308 if (PyErr_Occurred()) SWIG_fail;
18309 }
18310 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
18311 return resultobj;
18312 fail:
18313 return NULL;
18314 }
18315
18316
18317 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
18318 PyObject *obj;
18319 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18320 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
18321 Py_INCREF(obj);
18322 return Py_BuildValue((char *)"");
18323 }
18324 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
18325 PyObject *resultobj;
18326 wxWindow *arg1 = (wxWindow *) 0 ;
18327 wxWindowDC *result;
18328 PyObject * obj0 = 0 ;
18329 char *kwnames[] = {
18330 (char *) "win", NULL
18331 };
18332
18333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
18334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18335 if (SWIG_arg_fail(1)) SWIG_fail;
18336 {
18337 if (!wxPyCheckForApp()) SWIG_fail;
18338 PyThreadState* __tstate = wxPyBeginAllowThreads();
18339 result = (wxWindowDC *)new wxWindowDC(arg1);
18340
18341 wxPyEndAllowThreads(__tstate);
18342 if (PyErr_Occurred()) SWIG_fail;
18343 }
18344 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
18345 return resultobj;
18346 fail:
18347 return NULL;
18348 }
18349
18350
18351 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
18352 PyObject *obj;
18353 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18354 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
18355 Py_INCREF(obj);
18356 return Py_BuildValue((char *)"");
18357 }
18358 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
18359 PyObject *resultobj;
18360 wxDC *arg1 = 0 ;
18361 bool arg2 ;
18362 wxMirrorDC *result;
18363 PyObject * obj0 = 0 ;
18364 PyObject * obj1 = 0 ;
18365 char *kwnames[] = {
18366 (char *) "dc",(char *) "mirror", NULL
18367 };
18368
18369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
18370 {
18371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18372 if (SWIG_arg_fail(1)) SWIG_fail;
18373 if (arg1 == NULL) {
18374 SWIG_null_ref("wxDC");
18375 }
18376 if (SWIG_arg_fail(1)) SWIG_fail;
18377 }
18378 {
18379 arg2 = (bool)(SWIG_As_bool(obj1));
18380 if (SWIG_arg_fail(2)) SWIG_fail;
18381 }
18382 {
18383 if (!wxPyCheckForApp()) SWIG_fail;
18384 PyThreadState* __tstate = wxPyBeginAllowThreads();
18385 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
18386
18387 wxPyEndAllowThreads(__tstate);
18388 if (PyErr_Occurred()) SWIG_fail;
18389 }
18390 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
18391 return resultobj;
18392 fail:
18393 return NULL;
18394 }
18395
18396
18397 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
18398 PyObject *obj;
18399 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18400 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
18401 Py_INCREF(obj);
18402 return Py_BuildValue((char *)"");
18403 }
18404 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
18405 PyObject *resultobj;
18406 wxPrintData *arg1 = 0 ;
18407 wxPostScriptDC *result;
18408 PyObject * obj0 = 0 ;
18409 char *kwnames[] = {
18410 (char *) "printData", NULL
18411 };
18412
18413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
18414 {
18415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18416 if (SWIG_arg_fail(1)) SWIG_fail;
18417 if (arg1 == NULL) {
18418 SWIG_null_ref("wxPrintData");
18419 }
18420 if (SWIG_arg_fail(1)) SWIG_fail;
18421 }
18422 {
18423 if (!wxPyCheckForApp()) SWIG_fail;
18424 PyThreadState* __tstate = wxPyBeginAllowThreads();
18425 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
18426
18427 wxPyEndAllowThreads(__tstate);
18428 if (PyErr_Occurred()) SWIG_fail;
18429 }
18430 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
18431 return resultobj;
18432 fail:
18433 return NULL;
18434 }
18435
18436
18437 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
18438 PyObject *resultobj;
18439 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
18440 wxPrintData *result;
18441 PyObject * obj0 = 0 ;
18442 char *kwnames[] = {
18443 (char *) "self", NULL
18444 };
18445
18446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
18447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
18448 if (SWIG_arg_fail(1)) SWIG_fail;
18449 {
18450 PyThreadState* __tstate = wxPyBeginAllowThreads();
18451 {
18452 wxPrintData &_result_ref = (arg1)->GetPrintData();
18453 result = (wxPrintData *) &_result_ref;
18454 }
18455
18456 wxPyEndAllowThreads(__tstate);
18457 if (PyErr_Occurred()) SWIG_fail;
18458 }
18459 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
18460 return resultobj;
18461 fail:
18462 return NULL;
18463 }
18464
18465
18466 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
18467 PyObject *resultobj;
18468 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
18469 wxPrintData *arg2 = 0 ;
18470 PyObject * obj0 = 0 ;
18471 PyObject * obj1 = 0 ;
18472 char *kwnames[] = {
18473 (char *) "self",(char *) "data", NULL
18474 };
18475
18476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
18477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
18478 if (SWIG_arg_fail(1)) SWIG_fail;
18479 {
18480 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18481 if (SWIG_arg_fail(2)) SWIG_fail;
18482 if (arg2 == NULL) {
18483 SWIG_null_ref("wxPrintData");
18484 }
18485 if (SWIG_arg_fail(2)) SWIG_fail;
18486 }
18487 {
18488 PyThreadState* __tstate = wxPyBeginAllowThreads();
18489 (arg1)->SetPrintData((wxPrintData const &)*arg2);
18490
18491 wxPyEndAllowThreads(__tstate);
18492 if (PyErr_Occurred()) SWIG_fail;
18493 }
18494 Py_INCREF(Py_None); resultobj = Py_None;
18495 return resultobj;
18496 fail:
18497 return NULL;
18498 }
18499
18500
18501 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
18502 PyObject *resultobj;
18503 int arg1 ;
18504 PyObject * obj0 = 0 ;
18505 char *kwnames[] = {
18506 (char *) "ppi", NULL
18507 };
18508
18509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
18510 {
18511 arg1 = (int)(SWIG_As_int(obj0));
18512 if (SWIG_arg_fail(1)) SWIG_fail;
18513 }
18514 {
18515 PyThreadState* __tstate = wxPyBeginAllowThreads();
18516 wxPostScriptDC::SetResolution(arg1);
18517
18518 wxPyEndAllowThreads(__tstate);
18519 if (PyErr_Occurred()) SWIG_fail;
18520 }
18521 Py_INCREF(Py_None); resultobj = Py_None;
18522 return resultobj;
18523 fail:
18524 return NULL;
18525 }
18526
18527
18528 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
18529 PyObject *resultobj;
18530 int result;
18531 char *kwnames[] = {
18532 NULL
18533 };
18534
18535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
18536 {
18537 PyThreadState* __tstate = wxPyBeginAllowThreads();
18538 result = (int)wxPostScriptDC::GetResolution();
18539
18540 wxPyEndAllowThreads(__tstate);
18541 if (PyErr_Occurred()) SWIG_fail;
18542 }
18543 {
18544 resultobj = SWIG_From_int((int)(result));
18545 }
18546 return resultobj;
18547 fail:
18548 return NULL;
18549 }
18550
18551
18552 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
18553 PyObject *obj;
18554 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18555 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
18556 Py_INCREF(obj);
18557 return Py_BuildValue((char *)"");
18558 }
18559 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18560 PyObject *resultobj;
18561 wxString const &arg1_defvalue = wxPyEmptyString ;
18562 wxString *arg1 = (wxString *) &arg1_defvalue ;
18563 wxMetaFile *result;
18564 bool temp1 = false ;
18565 PyObject * obj0 = 0 ;
18566 char *kwnames[] = {
18567 (char *) "filename", NULL
18568 };
18569
18570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
18571 if (obj0) {
18572 {
18573 arg1 = wxString_in_helper(obj0);
18574 if (arg1 == NULL) SWIG_fail;
18575 temp1 = true;
18576 }
18577 }
18578 {
18579 if (!wxPyCheckForApp()) SWIG_fail;
18580 PyThreadState* __tstate = wxPyBeginAllowThreads();
18581 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
18582
18583 wxPyEndAllowThreads(__tstate);
18584 if (PyErr_Occurred()) SWIG_fail;
18585 }
18586 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
18587 {
18588 if (temp1)
18589 delete arg1;
18590 }
18591 return resultobj;
18592 fail:
18593 {
18594 if (temp1)
18595 delete arg1;
18596 }
18597 return NULL;
18598 }
18599
18600
18601 static PyObject *_wrap_delete_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18602 PyObject *resultobj;
18603 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18604 PyObject * obj0 = 0 ;
18605 char *kwnames[] = {
18606 (char *) "self", NULL
18607 };
18608
18609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MetaFile",kwnames,&obj0)) goto fail;
18610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18611 if (SWIG_arg_fail(1)) SWIG_fail;
18612 {
18613 PyThreadState* __tstate = wxPyBeginAllowThreads();
18614 delete arg1;
18615
18616 wxPyEndAllowThreads(__tstate);
18617 if (PyErr_Occurred()) SWIG_fail;
18618 }
18619 Py_INCREF(Py_None); resultobj = Py_None;
18620 return resultobj;
18621 fail:
18622 return NULL;
18623 }
18624
18625
18626 static PyObject *_wrap_MetaFile_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
18627 PyObject *resultobj;
18628 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18629 bool result;
18630 PyObject * obj0 = 0 ;
18631 char *kwnames[] = {
18632 (char *) "self", NULL
18633 };
18634
18635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_Ok",kwnames,&obj0)) goto fail;
18636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18637 if (SWIG_arg_fail(1)) SWIG_fail;
18638 {
18639 PyThreadState* __tstate = wxPyBeginAllowThreads();
18640 result = (bool)(arg1)->Ok();
18641
18642 wxPyEndAllowThreads(__tstate);
18643 if (PyErr_Occurred()) SWIG_fail;
18644 }
18645 {
18646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18647 }
18648 return resultobj;
18649 fail:
18650 return NULL;
18651 }
18652
18653
18654 static PyObject *_wrap_MetaFile_SetClipboard(PyObject *, PyObject *args, PyObject *kwargs) {
18655 PyObject *resultobj;
18656 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18657 int arg2 = (int) 0 ;
18658 int arg3 = (int) 0 ;
18659 bool result;
18660 PyObject * obj0 = 0 ;
18661 PyObject * obj1 = 0 ;
18662 PyObject * obj2 = 0 ;
18663 char *kwnames[] = {
18664 (char *) "self",(char *) "width",(char *) "height", NULL
18665 };
18666
18667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MetaFile_SetClipboard",kwnames,&obj0,&obj1,&obj2)) goto fail;
18668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18669 if (SWIG_arg_fail(1)) SWIG_fail;
18670 if (obj1) {
18671 {
18672 arg2 = (int)(SWIG_As_int(obj1));
18673 if (SWIG_arg_fail(2)) SWIG_fail;
18674 }
18675 }
18676 if (obj2) {
18677 {
18678 arg3 = (int)(SWIG_As_int(obj2));
18679 if (SWIG_arg_fail(3)) SWIG_fail;
18680 }
18681 }
18682 {
18683 PyThreadState* __tstate = wxPyBeginAllowThreads();
18684 result = (bool)(arg1)->SetClipboard(arg2,arg3);
18685
18686 wxPyEndAllowThreads(__tstate);
18687 if (PyErr_Occurred()) SWIG_fail;
18688 }
18689 {
18690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18691 }
18692 return resultobj;
18693 fail:
18694 return NULL;
18695 }
18696
18697
18698 static PyObject *_wrap_MetaFile_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18699 PyObject *resultobj;
18700 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18701 wxSize result;
18702 PyObject * obj0 = 0 ;
18703 char *kwnames[] = {
18704 (char *) "self", NULL
18705 };
18706
18707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetSize",kwnames,&obj0)) goto fail;
18708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18709 if (SWIG_arg_fail(1)) SWIG_fail;
18710 {
18711 PyThreadState* __tstate = wxPyBeginAllowThreads();
18712 result = (arg1)->GetSize();
18713
18714 wxPyEndAllowThreads(__tstate);
18715 if (PyErr_Occurred()) SWIG_fail;
18716 }
18717 {
18718 wxSize * resultptr;
18719 resultptr = new wxSize((wxSize &)(result));
18720 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18721 }
18722 return resultobj;
18723 fail:
18724 return NULL;
18725 }
18726
18727
18728 static PyObject *_wrap_MetaFile_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
18729 PyObject *resultobj;
18730 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18731 int result;
18732 PyObject * obj0 = 0 ;
18733 char *kwnames[] = {
18734 (char *) "self", NULL
18735 };
18736
18737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetWidth",kwnames,&obj0)) goto fail;
18738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18739 if (SWIG_arg_fail(1)) SWIG_fail;
18740 {
18741 PyThreadState* __tstate = wxPyBeginAllowThreads();
18742 result = (int)(arg1)->GetWidth();
18743
18744 wxPyEndAllowThreads(__tstate);
18745 if (PyErr_Occurred()) SWIG_fail;
18746 }
18747 {
18748 resultobj = SWIG_From_int((int)(result));
18749 }
18750 return resultobj;
18751 fail:
18752 return NULL;
18753 }
18754
18755
18756 static PyObject *_wrap_MetaFile_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
18757 PyObject *resultobj;
18758 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18759 int result;
18760 PyObject * obj0 = 0 ;
18761 char *kwnames[] = {
18762 (char *) "self", NULL
18763 };
18764
18765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetHeight",kwnames,&obj0)) goto fail;
18766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18767 if (SWIG_arg_fail(1)) SWIG_fail;
18768 {
18769 PyThreadState* __tstate = wxPyBeginAllowThreads();
18770 result = (int)(arg1)->GetHeight();
18771
18772 wxPyEndAllowThreads(__tstate);
18773 if (PyErr_Occurred()) SWIG_fail;
18774 }
18775 {
18776 resultobj = SWIG_From_int((int)(result));
18777 }
18778 return resultobj;
18779 fail:
18780 return NULL;
18781 }
18782
18783
18784 static PyObject *_wrap_MetaFile_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
18785 PyObject *resultobj;
18786 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18787 wxString *result;
18788 PyObject * obj0 = 0 ;
18789 char *kwnames[] = {
18790 (char *) "self", NULL
18791 };
18792
18793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetFileName",kwnames,&obj0)) goto fail;
18794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18795 if (SWIG_arg_fail(1)) SWIG_fail;
18796 {
18797 PyThreadState* __tstate = wxPyBeginAllowThreads();
18798 {
18799 wxString const &_result_ref = ((wxMetaFile const *)arg1)->GetFileName();
18800 result = (wxString *) &_result_ref;
18801 }
18802
18803 wxPyEndAllowThreads(__tstate);
18804 if (PyErr_Occurred()) SWIG_fail;
18805 }
18806 {
18807 #if wxUSE_UNICODE
18808 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18809 #else
18810 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18811 #endif
18812 }
18813 return resultobj;
18814 fail:
18815 return NULL;
18816 }
18817
18818
18819 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
18820 PyObject *obj;
18821 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18822 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
18823 Py_INCREF(obj);
18824 return Py_BuildValue((char *)"");
18825 }
18826 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
18827 PyObject *resultobj;
18828 wxString const &arg1_defvalue = wxPyEmptyString ;
18829 wxString *arg1 = (wxString *) &arg1_defvalue ;
18830 int arg2 = (int) 0 ;
18831 int arg3 = (int) 0 ;
18832 wxString const &arg4_defvalue = wxPyEmptyString ;
18833 wxString *arg4 = (wxString *) &arg4_defvalue ;
18834 wxMetaFileDC *result;
18835 bool temp1 = false ;
18836 bool temp4 = false ;
18837 PyObject * obj0 = 0 ;
18838 PyObject * obj1 = 0 ;
18839 PyObject * obj2 = 0 ;
18840 PyObject * obj3 = 0 ;
18841 char *kwnames[] = {
18842 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
18843 };
18844
18845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18846 if (obj0) {
18847 {
18848 arg1 = wxString_in_helper(obj0);
18849 if (arg1 == NULL) SWIG_fail;
18850 temp1 = true;
18851 }
18852 }
18853 if (obj1) {
18854 {
18855 arg2 = (int)(SWIG_As_int(obj1));
18856 if (SWIG_arg_fail(2)) SWIG_fail;
18857 }
18858 }
18859 if (obj2) {
18860 {
18861 arg3 = (int)(SWIG_As_int(obj2));
18862 if (SWIG_arg_fail(3)) SWIG_fail;
18863 }
18864 }
18865 if (obj3) {
18866 {
18867 arg4 = wxString_in_helper(obj3);
18868 if (arg4 == NULL) SWIG_fail;
18869 temp4 = true;
18870 }
18871 }
18872 {
18873 if (!wxPyCheckForApp()) SWIG_fail;
18874 PyThreadState* __tstate = wxPyBeginAllowThreads();
18875 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
18876
18877 wxPyEndAllowThreads(__tstate);
18878 if (PyErr_Occurred()) SWIG_fail;
18879 }
18880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
18881 {
18882 if (temp1)
18883 delete arg1;
18884 }
18885 {
18886 if (temp4)
18887 delete arg4;
18888 }
18889 return resultobj;
18890 fail:
18891 {
18892 if (temp1)
18893 delete arg1;
18894 }
18895 {
18896 if (temp4)
18897 delete arg4;
18898 }
18899 return NULL;
18900 }
18901
18902
18903 static PyObject *_wrap_MetaFileDC_Close(PyObject *, PyObject *args, PyObject *kwargs) {
18904 PyObject *resultobj;
18905 wxMetaFileDC *arg1 = (wxMetaFileDC *) 0 ;
18906 wxMetaFile *result;
18907 PyObject * obj0 = 0 ;
18908 char *kwnames[] = {
18909 (char *) "self", NULL
18910 };
18911
18912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFileDC_Close",kwnames,&obj0)) goto fail;
18913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFileDC, SWIG_POINTER_EXCEPTION | 0);
18914 if (SWIG_arg_fail(1)) SWIG_fail;
18915 {
18916 PyThreadState* __tstate = wxPyBeginAllowThreads();
18917 result = (wxMetaFile *)(arg1)->Close();
18918
18919 wxPyEndAllowThreads(__tstate);
18920 if (PyErr_Occurred()) SWIG_fail;
18921 }
18922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 0);
18923 return resultobj;
18924 fail:
18925 return NULL;
18926 }
18927
18928
18929 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
18930 PyObject *obj;
18931 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18932 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
18933 Py_INCREF(obj);
18934 return Py_BuildValue((char *)"");
18935 }
18936 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
18937 PyObject *resultobj;
18938 wxPrintData *arg1 = 0 ;
18939 wxPrinterDC *result;
18940 PyObject * obj0 = 0 ;
18941 char *kwnames[] = {
18942 (char *) "printData", NULL
18943 };
18944
18945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
18946 {
18947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18948 if (SWIG_arg_fail(1)) SWIG_fail;
18949 if (arg1 == NULL) {
18950 SWIG_null_ref("wxPrintData");
18951 }
18952 if (SWIG_arg_fail(1)) SWIG_fail;
18953 }
18954 {
18955 if (!wxPyCheckForApp()) SWIG_fail;
18956 PyThreadState* __tstate = wxPyBeginAllowThreads();
18957 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
18958
18959 wxPyEndAllowThreads(__tstate);
18960 if (PyErr_Occurred()) SWIG_fail;
18961 }
18962 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
18963 return resultobj;
18964 fail:
18965 return NULL;
18966 }
18967
18968
18969 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
18970 PyObject *obj;
18971 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18972 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
18973 Py_INCREF(obj);
18974 return Py_BuildValue((char *)"");
18975 }
18976 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18977 PyObject *resultobj;
18978 int arg1 ;
18979 int arg2 ;
18980 int arg3 = (int) true ;
18981 int arg4 = (int) 1 ;
18982 wxImageList *result;
18983 PyObject * obj0 = 0 ;
18984 PyObject * obj1 = 0 ;
18985 PyObject * obj2 = 0 ;
18986 PyObject * obj3 = 0 ;
18987 char *kwnames[] = {
18988 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
18989 };
18990
18991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18992 {
18993 arg1 = (int)(SWIG_As_int(obj0));
18994 if (SWIG_arg_fail(1)) SWIG_fail;
18995 }
18996 {
18997 arg2 = (int)(SWIG_As_int(obj1));
18998 if (SWIG_arg_fail(2)) SWIG_fail;
18999 }
19000 if (obj2) {
19001 {
19002 arg3 = (int)(SWIG_As_int(obj2));
19003 if (SWIG_arg_fail(3)) SWIG_fail;
19004 }
19005 }
19006 if (obj3) {
19007 {
19008 arg4 = (int)(SWIG_As_int(obj3));
19009 if (SWIG_arg_fail(4)) SWIG_fail;
19010 }
19011 }
19012 {
19013 if (!wxPyCheckForApp()) SWIG_fail;
19014 PyThreadState* __tstate = wxPyBeginAllowThreads();
19015 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
19016
19017 wxPyEndAllowThreads(__tstate);
19018 if (PyErr_Occurred()) SWIG_fail;
19019 }
19020 {
19021 resultobj = wxPyMake_wxObject(result, 1);
19022 }
19023 return resultobj;
19024 fail:
19025 return NULL;
19026 }
19027
19028
19029 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
19030 PyObject *resultobj;
19031 wxImageList *arg1 = (wxImageList *) 0 ;
19032 PyObject * obj0 = 0 ;
19033 char *kwnames[] = {
19034 (char *) "self", NULL
19035 };
19036
19037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
19038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19039 if (SWIG_arg_fail(1)) SWIG_fail;
19040 {
19041 PyThreadState* __tstate = wxPyBeginAllowThreads();
19042 delete arg1;
19043
19044 wxPyEndAllowThreads(__tstate);
19045 if (PyErr_Occurred()) SWIG_fail;
19046 }
19047 Py_INCREF(Py_None); resultobj = Py_None;
19048 return resultobj;
19049 fail:
19050 return NULL;
19051 }
19052
19053
19054 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
19055 PyObject *resultobj;
19056 wxImageList *arg1 = (wxImageList *) 0 ;
19057 wxBitmap *arg2 = 0 ;
19058 wxBitmap const &arg3_defvalue = wxNullBitmap ;
19059 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
19060 int result;
19061 PyObject * obj0 = 0 ;
19062 PyObject * obj1 = 0 ;
19063 PyObject * obj2 = 0 ;
19064 char *kwnames[] = {
19065 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
19066 };
19067
19068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
19069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19070 if (SWIG_arg_fail(1)) SWIG_fail;
19071 {
19072 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19073 if (SWIG_arg_fail(2)) SWIG_fail;
19074 if (arg2 == NULL) {
19075 SWIG_null_ref("wxBitmap");
19076 }
19077 if (SWIG_arg_fail(2)) SWIG_fail;
19078 }
19079 if (obj2) {
19080 {
19081 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19082 if (SWIG_arg_fail(3)) SWIG_fail;
19083 if (arg3 == NULL) {
19084 SWIG_null_ref("wxBitmap");
19085 }
19086 if (SWIG_arg_fail(3)) SWIG_fail;
19087 }
19088 }
19089 {
19090 PyThreadState* __tstate = wxPyBeginAllowThreads();
19091 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
19092
19093 wxPyEndAllowThreads(__tstate);
19094 if (PyErr_Occurred()) SWIG_fail;
19095 }
19096 {
19097 resultobj = SWIG_From_int((int)(result));
19098 }
19099 return resultobj;
19100 fail:
19101 return NULL;
19102 }
19103
19104
19105 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
19106 PyObject *resultobj;
19107 wxImageList *arg1 = (wxImageList *) 0 ;
19108 wxBitmap *arg2 = 0 ;
19109 wxColour *arg3 = 0 ;
19110 int result;
19111 wxColour temp3 ;
19112 PyObject * obj0 = 0 ;
19113 PyObject * obj1 = 0 ;
19114 PyObject * obj2 = 0 ;
19115 char *kwnames[] = {
19116 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
19117 };
19118
19119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
19120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19121 if (SWIG_arg_fail(1)) SWIG_fail;
19122 {
19123 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19124 if (SWIG_arg_fail(2)) SWIG_fail;
19125 if (arg2 == NULL) {
19126 SWIG_null_ref("wxBitmap");
19127 }
19128 if (SWIG_arg_fail(2)) SWIG_fail;
19129 }
19130 {
19131 arg3 = &temp3;
19132 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19133 }
19134 {
19135 PyThreadState* __tstate = wxPyBeginAllowThreads();
19136 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
19137
19138 wxPyEndAllowThreads(__tstate);
19139 if (PyErr_Occurred()) SWIG_fail;
19140 }
19141 {
19142 resultobj = SWIG_From_int((int)(result));
19143 }
19144 return resultobj;
19145 fail:
19146 return NULL;
19147 }
19148
19149
19150 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
19151 PyObject *resultobj;
19152 wxImageList *arg1 = (wxImageList *) 0 ;
19153 wxIcon *arg2 = 0 ;
19154 int result;
19155 PyObject * obj0 = 0 ;
19156 PyObject * obj1 = 0 ;
19157 char *kwnames[] = {
19158 (char *) "self",(char *) "icon", NULL
19159 };
19160
19161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
19162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19163 if (SWIG_arg_fail(1)) SWIG_fail;
19164 {
19165 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
19166 if (SWIG_arg_fail(2)) SWIG_fail;
19167 if (arg2 == NULL) {
19168 SWIG_null_ref("wxIcon");
19169 }
19170 if (SWIG_arg_fail(2)) SWIG_fail;
19171 }
19172 {
19173 PyThreadState* __tstate = wxPyBeginAllowThreads();
19174 result = (int)(arg1)->Add((wxIcon const &)*arg2);
19175
19176 wxPyEndAllowThreads(__tstate);
19177 if (PyErr_Occurred()) SWIG_fail;
19178 }
19179 {
19180 resultobj = SWIG_From_int((int)(result));
19181 }
19182 return resultobj;
19183 fail:
19184 return NULL;
19185 }
19186
19187
19188 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
19189 PyObject *resultobj;
19190 wxImageList *arg1 = (wxImageList *) 0 ;
19191 int arg2 ;
19192 wxBitmap *arg3 = 0 ;
19193 wxBitmap const &arg4_defvalue = wxNullBitmap ;
19194 wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
19195 bool result;
19196 PyObject * obj0 = 0 ;
19197 PyObject * obj1 = 0 ;
19198 PyObject * obj2 = 0 ;
19199 PyObject * obj3 = 0 ;
19200 char *kwnames[] = {
19201 (char *) "self",(char *) "index",(char *) "bitmap",(char *) "mask", NULL
19202 };
19203
19204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ImageList_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19206 if (SWIG_arg_fail(1)) SWIG_fail;
19207 {
19208 arg2 = (int)(SWIG_As_int(obj1));
19209 if (SWIG_arg_fail(2)) SWIG_fail;
19210 }
19211 {
19212 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19213 if (SWIG_arg_fail(3)) SWIG_fail;
19214 if (arg3 == NULL) {
19215 SWIG_null_ref("wxBitmap");
19216 }
19217 if (SWIG_arg_fail(3)) SWIG_fail;
19218 }
19219 if (obj3) {
19220 {
19221 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19222 if (SWIG_arg_fail(4)) SWIG_fail;
19223 if (arg4 == NULL) {
19224 SWIG_null_ref("wxBitmap");
19225 }
19226 if (SWIG_arg_fail(4)) SWIG_fail;
19227 }
19228 }
19229 {
19230 PyThreadState* __tstate = wxPyBeginAllowThreads();
19231 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3,(wxBitmap const &)*arg4);
19232
19233 wxPyEndAllowThreads(__tstate);
19234 if (PyErr_Occurred()) SWIG_fail;
19235 }
19236 {
19237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19238 }
19239 return resultobj;
19240 fail:
19241 return NULL;
19242 }
19243
19244
19245 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
19246 PyObject *resultobj;
19247 wxImageList *arg1 = (wxImageList *) 0 ;
19248 int arg2 ;
19249 wxDC *arg3 = 0 ;
19250 int arg4 ;
19251 int arg5 ;
19252 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
19253 bool arg7 = (bool) (bool)false ;
19254 bool result;
19255 PyObject * obj0 = 0 ;
19256 PyObject * obj1 = 0 ;
19257 PyObject * obj2 = 0 ;
19258 PyObject * obj3 = 0 ;
19259 PyObject * obj4 = 0 ;
19260 PyObject * obj5 = 0 ;
19261 PyObject * obj6 = 0 ;
19262 char *kwnames[] = {
19263 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
19264 };
19265
19266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19268 if (SWIG_arg_fail(1)) SWIG_fail;
19269 {
19270 arg2 = (int)(SWIG_As_int(obj1));
19271 if (SWIG_arg_fail(2)) SWIG_fail;
19272 }
19273 {
19274 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19275 if (SWIG_arg_fail(3)) SWIG_fail;
19276 if (arg3 == NULL) {
19277 SWIG_null_ref("wxDC");
19278 }
19279 if (SWIG_arg_fail(3)) SWIG_fail;
19280 }
19281 {
19282 arg4 = (int)(SWIG_As_int(obj3));
19283 if (SWIG_arg_fail(4)) SWIG_fail;
19284 }
19285 {
19286 arg5 = (int)(SWIG_As_int(obj4));
19287 if (SWIG_arg_fail(5)) SWIG_fail;
19288 }
19289 if (obj5) {
19290 {
19291 arg6 = (int)(SWIG_As_int(obj5));
19292 if (SWIG_arg_fail(6)) SWIG_fail;
19293 }
19294 }
19295 if (obj6) {
19296 {
19297 arg7 = (bool const)(SWIG_As_bool(obj6));
19298 if (SWIG_arg_fail(7)) SWIG_fail;
19299 }
19300 }
19301 {
19302 PyThreadState* __tstate = wxPyBeginAllowThreads();
19303 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
19304
19305 wxPyEndAllowThreads(__tstate);
19306 if (PyErr_Occurred()) SWIG_fail;
19307 }
19308 {
19309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19310 }
19311 return resultobj;
19312 fail:
19313 return NULL;
19314 }
19315
19316
19317 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
19318 PyObject *resultobj;
19319 wxImageList *arg1 = (wxImageList *) 0 ;
19320 int result;
19321 PyObject * obj0 = 0 ;
19322 char *kwnames[] = {
19323 (char *) "self", NULL
19324 };
19325
19326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
19327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19328 if (SWIG_arg_fail(1)) SWIG_fail;
19329 {
19330 PyThreadState* __tstate = wxPyBeginAllowThreads();
19331 result = (int)(arg1)->GetImageCount();
19332
19333 wxPyEndAllowThreads(__tstate);
19334 if (PyErr_Occurred()) SWIG_fail;
19335 }
19336 {
19337 resultobj = SWIG_From_int((int)(result));
19338 }
19339 return resultobj;
19340 fail:
19341 return NULL;
19342 }
19343
19344
19345 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
19346 PyObject *resultobj;
19347 wxImageList *arg1 = (wxImageList *) 0 ;
19348 int arg2 ;
19349 bool result;
19350 PyObject * obj0 = 0 ;
19351 PyObject * obj1 = 0 ;
19352 char *kwnames[] = {
19353 (char *) "self",(char *) "index", NULL
19354 };
19355
19356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
19357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19358 if (SWIG_arg_fail(1)) SWIG_fail;
19359 {
19360 arg2 = (int)(SWIG_As_int(obj1));
19361 if (SWIG_arg_fail(2)) SWIG_fail;
19362 }
19363 {
19364 PyThreadState* __tstate = wxPyBeginAllowThreads();
19365 result = (bool)(arg1)->Remove(arg2);
19366
19367 wxPyEndAllowThreads(__tstate);
19368 if (PyErr_Occurred()) SWIG_fail;
19369 }
19370 {
19371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19372 }
19373 return resultobj;
19374 fail:
19375 return NULL;
19376 }
19377
19378
19379 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
19380 PyObject *resultobj;
19381 wxImageList *arg1 = (wxImageList *) 0 ;
19382 bool result;
19383 PyObject * obj0 = 0 ;
19384 char *kwnames[] = {
19385 (char *) "self", NULL
19386 };
19387
19388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
19389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19390 if (SWIG_arg_fail(1)) SWIG_fail;
19391 {
19392 PyThreadState* __tstate = wxPyBeginAllowThreads();
19393 result = (bool)(arg1)->RemoveAll();
19394
19395 wxPyEndAllowThreads(__tstate);
19396 if (PyErr_Occurred()) SWIG_fail;
19397 }
19398 {
19399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19400 }
19401 return resultobj;
19402 fail:
19403 return NULL;
19404 }
19405
19406
19407 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19408 PyObject *resultobj;
19409 wxImageList *arg1 = (wxImageList *) 0 ;
19410 int arg2 ;
19411 int *arg3 = 0 ;
19412 int *arg4 = 0 ;
19413 int temp3 ;
19414 int res3 = 0 ;
19415 int temp4 ;
19416 int res4 = 0 ;
19417 PyObject * obj0 = 0 ;
19418 PyObject * obj1 = 0 ;
19419 char *kwnames[] = {
19420 (char *) "self",(char *) "index", NULL
19421 };
19422
19423 arg3 = &temp3; res3 = SWIG_NEWOBJ;
19424 arg4 = &temp4; res4 = SWIG_NEWOBJ;
19425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
19426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19427 if (SWIG_arg_fail(1)) SWIG_fail;
19428 {
19429 arg2 = (int)(SWIG_As_int(obj1));
19430 if (SWIG_arg_fail(2)) SWIG_fail;
19431 }
19432 {
19433 PyThreadState* __tstate = wxPyBeginAllowThreads();
19434 (arg1)->GetSize(arg2,*arg3,*arg4);
19435
19436 wxPyEndAllowThreads(__tstate);
19437 if (PyErr_Occurred()) SWIG_fail;
19438 }
19439 Py_INCREF(Py_None); resultobj = Py_None;
19440 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19441 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19442 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
19443 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
19444 return resultobj;
19445 fail:
19446 return NULL;
19447 }
19448
19449
19450 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
19451 PyObject *obj;
19452 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19453 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
19454 Py_INCREF(obj);
19455 return Py_BuildValue((char *)"");
19456 }
19457 static int _wrap_NORMAL_FONT_set(PyObject *) {
19458 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
19459 return 1;
19460 }
19461
19462
19463 static PyObject *_wrap_NORMAL_FONT_get(void) {
19464 PyObject *pyobj;
19465
19466 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
19467 return pyobj;
19468 }
19469
19470
19471 static int _wrap_SMALL_FONT_set(PyObject *) {
19472 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
19473 return 1;
19474 }
19475
19476
19477 static PyObject *_wrap_SMALL_FONT_get(void) {
19478 PyObject *pyobj;
19479
19480 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
19481 return pyobj;
19482 }
19483
19484
19485 static int _wrap_ITALIC_FONT_set(PyObject *) {
19486 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
19487 return 1;
19488 }
19489
19490
19491 static PyObject *_wrap_ITALIC_FONT_get(void) {
19492 PyObject *pyobj;
19493
19494 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
19495 return pyobj;
19496 }
19497
19498
19499 static int _wrap_SWISS_FONT_set(PyObject *) {
19500 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
19501 return 1;
19502 }
19503
19504
19505 static PyObject *_wrap_SWISS_FONT_get(void) {
19506 PyObject *pyobj;
19507
19508 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
19509 return pyobj;
19510 }
19511
19512
19513 static int _wrap_RED_PEN_set(PyObject *) {
19514 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
19515 return 1;
19516 }
19517
19518
19519 static PyObject *_wrap_RED_PEN_get(void) {
19520 PyObject *pyobj;
19521
19522 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
19523 return pyobj;
19524 }
19525
19526
19527 static int _wrap_CYAN_PEN_set(PyObject *) {
19528 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
19529 return 1;
19530 }
19531
19532
19533 static PyObject *_wrap_CYAN_PEN_get(void) {
19534 PyObject *pyobj;
19535
19536 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
19537 return pyobj;
19538 }
19539
19540
19541 static int _wrap_GREEN_PEN_set(PyObject *) {
19542 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
19543 return 1;
19544 }
19545
19546
19547 static PyObject *_wrap_GREEN_PEN_get(void) {
19548 PyObject *pyobj;
19549
19550 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
19551 return pyobj;
19552 }
19553
19554
19555 static int _wrap_BLACK_PEN_set(PyObject *) {
19556 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
19557 return 1;
19558 }
19559
19560
19561 static PyObject *_wrap_BLACK_PEN_get(void) {
19562 PyObject *pyobj;
19563
19564 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
19565 return pyobj;
19566 }
19567
19568
19569 static int _wrap_WHITE_PEN_set(PyObject *) {
19570 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
19571 return 1;
19572 }
19573
19574
19575 static PyObject *_wrap_WHITE_PEN_get(void) {
19576 PyObject *pyobj;
19577
19578 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
19579 return pyobj;
19580 }
19581
19582
19583 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
19584 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
19585 return 1;
19586 }
19587
19588
19589 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
19590 PyObject *pyobj;
19591
19592 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
19593 return pyobj;
19594 }
19595
19596
19597 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
19598 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
19599 return 1;
19600 }
19601
19602
19603 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
19604 PyObject *pyobj;
19605
19606 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
19607 return pyobj;
19608 }
19609
19610
19611 static int _wrap_GREY_PEN_set(PyObject *) {
19612 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
19613 return 1;
19614 }
19615
19616
19617 static PyObject *_wrap_GREY_PEN_get(void) {
19618 PyObject *pyobj;
19619
19620 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
19621 return pyobj;
19622 }
19623
19624
19625 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
19626 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
19627 return 1;
19628 }
19629
19630
19631 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
19632 PyObject *pyobj;
19633
19634 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19635 return pyobj;
19636 }
19637
19638
19639 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
19640 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
19641 return 1;
19642 }
19643
19644
19645 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
19646 PyObject *pyobj;
19647
19648 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19649 return pyobj;
19650 }
19651
19652
19653 static int _wrap_BLUE_BRUSH_set(PyObject *) {
19654 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
19655 return 1;
19656 }
19657
19658
19659 static PyObject *_wrap_BLUE_BRUSH_get(void) {
19660 PyObject *pyobj;
19661
19662 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19663 return pyobj;
19664 }
19665
19666
19667 static int _wrap_GREEN_BRUSH_set(PyObject *) {
19668 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
19669 return 1;
19670 }
19671
19672
19673 static PyObject *_wrap_GREEN_BRUSH_get(void) {
19674 PyObject *pyobj;
19675
19676 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19677 return pyobj;
19678 }
19679
19680
19681 static int _wrap_WHITE_BRUSH_set(PyObject *) {
19682 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
19683 return 1;
19684 }
19685
19686
19687 static PyObject *_wrap_WHITE_BRUSH_get(void) {
19688 PyObject *pyobj;
19689
19690 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19691 return pyobj;
19692 }
19693
19694
19695 static int _wrap_BLACK_BRUSH_set(PyObject *) {
19696 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
19697 return 1;
19698 }
19699
19700
19701 static PyObject *_wrap_BLACK_BRUSH_get(void) {
19702 PyObject *pyobj;
19703
19704 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
19705 return pyobj;
19706 }
19707
19708
19709 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
19710 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
19711 return 1;
19712 }
19713
19714
19715 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
19716 PyObject *pyobj;
19717
19718 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
19719 return pyobj;
19720 }
19721
19722
19723 static int _wrap_CYAN_BRUSH_set(PyObject *) {
19724 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
19725 return 1;
19726 }
19727
19728
19729 static PyObject *_wrap_CYAN_BRUSH_get(void) {
19730 PyObject *pyobj;
19731
19732 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19733 return pyobj;
19734 }
19735
19736
19737 static int _wrap_RED_BRUSH_set(PyObject *) {
19738 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
19739 return 1;
19740 }
19741
19742
19743 static PyObject *_wrap_RED_BRUSH_get(void) {
19744 PyObject *pyobj;
19745
19746 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
19747 return pyobj;
19748 }
19749
19750
19751 static int _wrap_GREY_BRUSH_set(PyObject *) {
19752 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
19753 return 1;
19754 }
19755
19756
19757 static PyObject *_wrap_GREY_BRUSH_get(void) {
19758 PyObject *pyobj;
19759
19760 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19761 return pyobj;
19762 }
19763
19764
19765 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
19766 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
19767 return 1;
19768 }
19769
19770
19771 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
19772 PyObject *pyobj;
19773
19774 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19775 return pyobj;
19776 }
19777
19778
19779 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
19780 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
19781 return 1;
19782 }
19783
19784
19785 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
19786 PyObject *pyobj;
19787
19788 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19789 return pyobj;
19790 }
19791
19792
19793 static int _wrap_BLACK_set(PyObject *) {
19794 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
19795 return 1;
19796 }
19797
19798
19799 static PyObject *_wrap_BLACK_get(void) {
19800 PyObject *pyobj;
19801
19802 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
19803 return pyobj;
19804 }
19805
19806
19807 static int _wrap_WHITE_set(PyObject *) {
19808 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
19809 return 1;
19810 }
19811
19812
19813 static PyObject *_wrap_WHITE_get(void) {
19814 PyObject *pyobj;
19815
19816 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
19817 return pyobj;
19818 }
19819
19820
19821 static int _wrap_RED_set(PyObject *) {
19822 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
19823 return 1;
19824 }
19825
19826
19827 static PyObject *_wrap_RED_get(void) {
19828 PyObject *pyobj;
19829
19830 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
19831 return pyobj;
19832 }
19833
19834
19835 static int _wrap_BLUE_set(PyObject *) {
19836 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
19837 return 1;
19838 }
19839
19840
19841 static PyObject *_wrap_BLUE_get(void) {
19842 PyObject *pyobj;
19843
19844 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
19845 return pyobj;
19846 }
19847
19848
19849 static int _wrap_GREEN_set(PyObject *) {
19850 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
19851 return 1;
19852 }
19853
19854
19855 static PyObject *_wrap_GREEN_get(void) {
19856 PyObject *pyobj;
19857
19858 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
19859 return pyobj;
19860 }
19861
19862
19863 static int _wrap_CYAN_set(PyObject *) {
19864 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
19865 return 1;
19866 }
19867
19868
19869 static PyObject *_wrap_CYAN_get(void) {
19870 PyObject *pyobj;
19871
19872 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
19873 return pyobj;
19874 }
19875
19876
19877 static int _wrap_LIGHT_GREY_set(PyObject *) {
19878 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
19879 return 1;
19880 }
19881
19882
19883 static PyObject *_wrap_LIGHT_GREY_get(void) {
19884 PyObject *pyobj;
19885
19886 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
19887 return pyobj;
19888 }
19889
19890
19891 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
19892 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
19893 return 1;
19894 }
19895
19896
19897 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
19898 PyObject *pyobj;
19899
19900 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
19901 return pyobj;
19902 }
19903
19904
19905 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
19906 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
19907 return 1;
19908 }
19909
19910
19911 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
19912 PyObject *pyobj;
19913
19914 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19915 return pyobj;
19916 }
19917
19918
19919 static int _wrap_CROSS_CURSOR_set(PyObject *) {
19920 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
19921 return 1;
19922 }
19923
19924
19925 static PyObject *_wrap_CROSS_CURSOR_get(void) {
19926 PyObject *pyobj;
19927
19928 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19929 return pyobj;
19930 }
19931
19932
19933 static int _wrap_NullBitmap_set(PyObject *) {
19934 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
19935 return 1;
19936 }
19937
19938
19939 static PyObject *_wrap_NullBitmap_get(void) {
19940 PyObject *pyobj;
19941
19942 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
19943 return pyobj;
19944 }
19945
19946
19947 static int _wrap_NullIcon_set(PyObject *) {
19948 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
19949 return 1;
19950 }
19951
19952
19953 static PyObject *_wrap_NullIcon_get(void) {
19954 PyObject *pyobj;
19955
19956 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
19957 return pyobj;
19958 }
19959
19960
19961 static int _wrap_NullCursor_set(PyObject *) {
19962 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
19963 return 1;
19964 }
19965
19966
19967 static PyObject *_wrap_NullCursor_get(void) {
19968 PyObject *pyobj;
19969
19970 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
19971 return pyobj;
19972 }
19973
19974
19975 static int _wrap_NullPen_set(PyObject *) {
19976 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
19977 return 1;
19978 }
19979
19980
19981 static PyObject *_wrap_NullPen_get(void) {
19982 PyObject *pyobj;
19983
19984 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
19985 return pyobj;
19986 }
19987
19988
19989 static int _wrap_NullBrush_set(PyObject *) {
19990 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
19991 return 1;
19992 }
19993
19994
19995 static PyObject *_wrap_NullBrush_get(void) {
19996 PyObject *pyobj;
19997
19998 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
19999 return pyobj;
20000 }
20001
20002
20003 static int _wrap_NullPalette_set(PyObject *) {
20004 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
20005 return 1;
20006 }
20007
20008
20009 static PyObject *_wrap_NullPalette_get(void) {
20010 PyObject *pyobj;
20011
20012 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
20013 return pyobj;
20014 }
20015
20016
20017 static int _wrap_NullFont_set(PyObject *) {
20018 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
20019 return 1;
20020 }
20021
20022
20023 static PyObject *_wrap_NullFont_get(void) {
20024 PyObject *pyobj;
20025
20026 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
20027 return pyobj;
20028 }
20029
20030
20031 static int _wrap_NullColour_set(PyObject *) {
20032 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
20033 return 1;
20034 }
20035
20036
20037 static PyObject *_wrap_NullColour_get(void) {
20038 PyObject *pyobj;
20039
20040 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
20041 return pyobj;
20042 }
20043
20044
20045 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
20046 PyObject *resultobj;
20047 wxPenList *arg1 = (wxPenList *) 0 ;
20048 wxPen *arg2 = (wxPen *) 0 ;
20049 PyObject * obj0 = 0 ;
20050 PyObject * obj1 = 0 ;
20051 char *kwnames[] = {
20052 (char *) "self",(char *) "pen", NULL
20053 };
20054
20055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
20056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20057 if (SWIG_arg_fail(1)) SWIG_fail;
20058 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
20059 if (SWIG_arg_fail(2)) SWIG_fail;
20060 {
20061 PyThreadState* __tstate = wxPyBeginAllowThreads();
20062 (arg1)->AddPen(arg2);
20063
20064 wxPyEndAllowThreads(__tstate);
20065 if (PyErr_Occurred()) SWIG_fail;
20066 }
20067 Py_INCREF(Py_None); resultobj = Py_None;
20068 return resultobj;
20069 fail:
20070 return NULL;
20071 }
20072
20073
20074 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
20075 PyObject *resultobj;
20076 wxPenList *arg1 = (wxPenList *) 0 ;
20077 wxColour *arg2 = 0 ;
20078 int arg3 ;
20079 int arg4 ;
20080 wxPen *result;
20081 wxColour temp2 ;
20082 PyObject * obj0 = 0 ;
20083 PyObject * obj1 = 0 ;
20084 PyObject * obj2 = 0 ;
20085 PyObject * obj3 = 0 ;
20086 char *kwnames[] = {
20087 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
20088 };
20089
20090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20092 if (SWIG_arg_fail(1)) SWIG_fail;
20093 {
20094 arg2 = &temp2;
20095 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20096 }
20097 {
20098 arg3 = (int)(SWIG_As_int(obj2));
20099 if (SWIG_arg_fail(3)) SWIG_fail;
20100 }
20101 {
20102 arg4 = (int)(SWIG_As_int(obj3));
20103 if (SWIG_arg_fail(4)) SWIG_fail;
20104 }
20105 {
20106 PyThreadState* __tstate = wxPyBeginAllowThreads();
20107 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
20108
20109 wxPyEndAllowThreads(__tstate);
20110 if (PyErr_Occurred()) SWIG_fail;
20111 }
20112 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
20113 return resultobj;
20114 fail:
20115 return NULL;
20116 }
20117
20118
20119 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
20120 PyObject *resultobj;
20121 wxPenList *arg1 = (wxPenList *) 0 ;
20122 wxPen *arg2 = (wxPen *) 0 ;
20123 PyObject * obj0 = 0 ;
20124 PyObject * obj1 = 0 ;
20125 char *kwnames[] = {
20126 (char *) "self",(char *) "pen", NULL
20127 };
20128
20129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
20130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20131 if (SWIG_arg_fail(1)) SWIG_fail;
20132 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
20133 if (SWIG_arg_fail(2)) SWIG_fail;
20134 {
20135 PyThreadState* __tstate = wxPyBeginAllowThreads();
20136 (arg1)->RemovePen(arg2);
20137
20138 wxPyEndAllowThreads(__tstate);
20139 if (PyErr_Occurred()) SWIG_fail;
20140 }
20141 Py_INCREF(Py_None); resultobj = Py_None;
20142 return resultobj;
20143 fail:
20144 return NULL;
20145 }
20146
20147
20148 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20149 PyObject *resultobj;
20150 wxPenList *arg1 = (wxPenList *) 0 ;
20151 int result;
20152 PyObject * obj0 = 0 ;
20153 char *kwnames[] = {
20154 (char *) "self", NULL
20155 };
20156
20157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
20158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20159 if (SWIG_arg_fail(1)) SWIG_fail;
20160 {
20161 PyThreadState* __tstate = wxPyBeginAllowThreads();
20162 result = (int)(arg1)->GetCount();
20163
20164 wxPyEndAllowThreads(__tstate);
20165 if (PyErr_Occurred()) SWIG_fail;
20166 }
20167 {
20168 resultobj = SWIG_From_int((int)(result));
20169 }
20170 return resultobj;
20171 fail:
20172 return NULL;
20173 }
20174
20175
20176 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
20177 PyObject *obj;
20178 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20179 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
20180 Py_INCREF(obj);
20181 return Py_BuildValue((char *)"");
20182 }
20183 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20184 PyObject *resultobj;
20185 wxBrushList *arg1 = (wxBrushList *) 0 ;
20186 wxBrush *arg2 = (wxBrush *) 0 ;
20187 PyObject * obj0 = 0 ;
20188 PyObject * obj1 = 0 ;
20189 char *kwnames[] = {
20190 (char *) "self",(char *) "brush", NULL
20191 };
20192
20193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
20194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20195 if (SWIG_arg_fail(1)) SWIG_fail;
20196 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
20197 if (SWIG_arg_fail(2)) SWIG_fail;
20198 {
20199 PyThreadState* __tstate = wxPyBeginAllowThreads();
20200 (arg1)->AddBrush(arg2);
20201
20202 wxPyEndAllowThreads(__tstate);
20203 if (PyErr_Occurred()) SWIG_fail;
20204 }
20205 Py_INCREF(Py_None); resultobj = Py_None;
20206 return resultobj;
20207 fail:
20208 return NULL;
20209 }
20210
20211
20212 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20213 PyObject *resultobj;
20214 wxBrushList *arg1 = (wxBrushList *) 0 ;
20215 wxColour *arg2 = 0 ;
20216 int arg3 ;
20217 wxBrush *result;
20218 wxColour temp2 ;
20219 PyObject * obj0 = 0 ;
20220 PyObject * obj1 = 0 ;
20221 PyObject * obj2 = 0 ;
20222 char *kwnames[] = {
20223 (char *) "self",(char *) "colour",(char *) "style", NULL
20224 };
20225
20226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
20227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20228 if (SWIG_arg_fail(1)) SWIG_fail;
20229 {
20230 arg2 = &temp2;
20231 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20232 }
20233 {
20234 arg3 = (int)(SWIG_As_int(obj2));
20235 if (SWIG_arg_fail(3)) SWIG_fail;
20236 }
20237 {
20238 PyThreadState* __tstate = wxPyBeginAllowThreads();
20239 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
20240
20241 wxPyEndAllowThreads(__tstate);
20242 if (PyErr_Occurred()) SWIG_fail;
20243 }
20244 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
20245 return resultobj;
20246 fail:
20247 return NULL;
20248 }
20249
20250
20251 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20252 PyObject *resultobj;
20253 wxBrushList *arg1 = (wxBrushList *) 0 ;
20254 wxBrush *arg2 = (wxBrush *) 0 ;
20255 PyObject * obj0 = 0 ;
20256 PyObject * obj1 = 0 ;
20257 char *kwnames[] = {
20258 (char *) "self",(char *) "brush", NULL
20259 };
20260
20261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
20262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20263 if (SWIG_arg_fail(1)) SWIG_fail;
20264 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
20265 if (SWIG_arg_fail(2)) SWIG_fail;
20266 {
20267 PyThreadState* __tstate = wxPyBeginAllowThreads();
20268 (arg1)->RemoveBrush(arg2);
20269
20270 wxPyEndAllowThreads(__tstate);
20271 if (PyErr_Occurred()) SWIG_fail;
20272 }
20273 Py_INCREF(Py_None); resultobj = Py_None;
20274 return resultobj;
20275 fail:
20276 return NULL;
20277 }
20278
20279
20280 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20281 PyObject *resultobj;
20282 wxBrushList *arg1 = (wxBrushList *) 0 ;
20283 int result;
20284 PyObject * obj0 = 0 ;
20285 char *kwnames[] = {
20286 (char *) "self", NULL
20287 };
20288
20289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
20290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20291 if (SWIG_arg_fail(1)) SWIG_fail;
20292 {
20293 PyThreadState* __tstate = wxPyBeginAllowThreads();
20294 result = (int)(arg1)->GetCount();
20295
20296 wxPyEndAllowThreads(__tstate);
20297 if (PyErr_Occurred()) SWIG_fail;
20298 }
20299 {
20300 resultobj = SWIG_From_int((int)(result));
20301 }
20302 return resultobj;
20303 fail:
20304 return NULL;
20305 }
20306
20307
20308 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
20309 PyObject *obj;
20310 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20311 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
20312 Py_INCREF(obj);
20313 return Py_BuildValue((char *)"");
20314 }
20315 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
20316 PyObject *resultobj;
20317 wxColourDatabase *result;
20318 char *kwnames[] = {
20319 NULL
20320 };
20321
20322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
20323 {
20324 if (!wxPyCheckForApp()) SWIG_fail;
20325 PyThreadState* __tstate = wxPyBeginAllowThreads();
20326 result = (wxColourDatabase *)new wxColourDatabase();
20327
20328 wxPyEndAllowThreads(__tstate);
20329 if (PyErr_Occurred()) SWIG_fail;
20330 }
20331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
20332 return resultobj;
20333 fail:
20334 return NULL;
20335 }
20336
20337
20338 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
20339 PyObject *resultobj;
20340 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20341 PyObject * obj0 = 0 ;
20342 char *kwnames[] = {
20343 (char *) "self", NULL
20344 };
20345
20346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
20347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20348 if (SWIG_arg_fail(1)) SWIG_fail;
20349 {
20350 PyThreadState* __tstate = wxPyBeginAllowThreads();
20351 delete arg1;
20352
20353 wxPyEndAllowThreads(__tstate);
20354 if (PyErr_Occurred()) SWIG_fail;
20355 }
20356 Py_INCREF(Py_None); resultobj = Py_None;
20357 return resultobj;
20358 fail:
20359 return NULL;
20360 }
20361
20362
20363 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
20364 PyObject *resultobj;
20365 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20366 wxString *arg2 = 0 ;
20367 wxColour result;
20368 bool temp2 = false ;
20369 PyObject * obj0 = 0 ;
20370 PyObject * obj1 = 0 ;
20371 char *kwnames[] = {
20372 (char *) "self",(char *) "name", NULL
20373 };
20374
20375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
20376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20377 if (SWIG_arg_fail(1)) SWIG_fail;
20378 {
20379 arg2 = wxString_in_helper(obj1);
20380 if (arg2 == NULL) SWIG_fail;
20381 temp2 = true;
20382 }
20383 {
20384 PyThreadState* __tstate = wxPyBeginAllowThreads();
20385 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
20386
20387 wxPyEndAllowThreads(__tstate);
20388 if (PyErr_Occurred()) SWIG_fail;
20389 }
20390 {
20391 wxColour * resultptr;
20392 resultptr = new wxColour((wxColour &)(result));
20393 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20394 }
20395 {
20396 if (temp2)
20397 delete arg2;
20398 }
20399 return resultobj;
20400 fail:
20401 {
20402 if (temp2)
20403 delete arg2;
20404 }
20405 return NULL;
20406 }
20407
20408
20409 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
20410 PyObject *resultobj;
20411 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20412 wxColour *arg2 = 0 ;
20413 wxString result;
20414 wxColour temp2 ;
20415 PyObject * obj0 = 0 ;
20416 PyObject * obj1 = 0 ;
20417 char *kwnames[] = {
20418 (char *) "self",(char *) "colour", NULL
20419 };
20420
20421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
20422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20423 if (SWIG_arg_fail(1)) SWIG_fail;
20424 {
20425 arg2 = &temp2;
20426 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20427 }
20428 {
20429 PyThreadState* __tstate = wxPyBeginAllowThreads();
20430 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
20431
20432 wxPyEndAllowThreads(__tstate);
20433 if (PyErr_Occurred()) SWIG_fail;
20434 }
20435 {
20436 #if wxUSE_UNICODE
20437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20438 #else
20439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20440 #endif
20441 }
20442 return resultobj;
20443 fail:
20444 return NULL;
20445 }
20446
20447
20448 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
20449 PyObject *resultobj;
20450 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20451 wxString *arg2 = 0 ;
20452 wxColour *arg3 = 0 ;
20453 bool temp2 = false ;
20454 wxColour temp3 ;
20455 PyObject * obj0 = 0 ;
20456 PyObject * obj1 = 0 ;
20457 PyObject * obj2 = 0 ;
20458 char *kwnames[] = {
20459 (char *) "self",(char *) "name",(char *) "colour", NULL
20460 };
20461
20462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
20463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20464 if (SWIG_arg_fail(1)) SWIG_fail;
20465 {
20466 arg2 = wxString_in_helper(obj1);
20467 if (arg2 == NULL) SWIG_fail;
20468 temp2 = true;
20469 }
20470 {
20471 arg3 = &temp3;
20472 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20473 }
20474 {
20475 PyThreadState* __tstate = wxPyBeginAllowThreads();
20476 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
20477
20478 wxPyEndAllowThreads(__tstate);
20479 if (PyErr_Occurred()) SWIG_fail;
20480 }
20481 Py_INCREF(Py_None); resultobj = Py_None;
20482 {
20483 if (temp2)
20484 delete arg2;
20485 }
20486 return resultobj;
20487 fail:
20488 {
20489 if (temp2)
20490 delete arg2;
20491 }
20492 return NULL;
20493 }
20494
20495
20496 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
20497 PyObject *resultobj;
20498 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20499 wxString *arg2 = 0 ;
20500 int arg3 ;
20501 int arg4 ;
20502 int arg5 ;
20503 bool temp2 = false ;
20504 PyObject * obj0 = 0 ;
20505 PyObject * obj1 = 0 ;
20506 PyObject * obj2 = 0 ;
20507 PyObject * obj3 = 0 ;
20508 PyObject * obj4 = 0 ;
20509 char *kwnames[] = {
20510 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
20511 };
20512
20513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20515 if (SWIG_arg_fail(1)) SWIG_fail;
20516 {
20517 arg2 = wxString_in_helper(obj1);
20518 if (arg2 == NULL) SWIG_fail;
20519 temp2 = true;
20520 }
20521 {
20522 arg3 = (int)(SWIG_As_int(obj2));
20523 if (SWIG_arg_fail(3)) SWIG_fail;
20524 }
20525 {
20526 arg4 = (int)(SWIG_As_int(obj3));
20527 if (SWIG_arg_fail(4)) SWIG_fail;
20528 }
20529 {
20530 arg5 = (int)(SWIG_As_int(obj4));
20531 if (SWIG_arg_fail(5)) SWIG_fail;
20532 }
20533 {
20534 PyThreadState* __tstate = wxPyBeginAllowThreads();
20535 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
20536
20537 wxPyEndAllowThreads(__tstate);
20538 if (PyErr_Occurred()) SWIG_fail;
20539 }
20540 Py_INCREF(Py_None); resultobj = Py_None;
20541 {
20542 if (temp2)
20543 delete arg2;
20544 }
20545 return resultobj;
20546 fail:
20547 {
20548 if (temp2)
20549 delete arg2;
20550 }
20551 return NULL;
20552 }
20553
20554
20555 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
20556 PyObject *obj;
20557 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20558 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
20559 Py_INCREF(obj);
20560 return Py_BuildValue((char *)"");
20561 }
20562 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
20563 PyObject *resultobj;
20564 wxFontList *arg1 = (wxFontList *) 0 ;
20565 wxFont *arg2 = (wxFont *) 0 ;
20566 PyObject * obj0 = 0 ;
20567 PyObject * obj1 = 0 ;
20568 char *kwnames[] = {
20569 (char *) "self",(char *) "font", NULL
20570 };
20571
20572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
20573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20574 if (SWIG_arg_fail(1)) SWIG_fail;
20575 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20576 if (SWIG_arg_fail(2)) SWIG_fail;
20577 {
20578 PyThreadState* __tstate = wxPyBeginAllowThreads();
20579 (arg1)->AddFont(arg2);
20580
20581 wxPyEndAllowThreads(__tstate);
20582 if (PyErr_Occurred()) SWIG_fail;
20583 }
20584 Py_INCREF(Py_None); resultobj = Py_None;
20585 return resultobj;
20586 fail:
20587 return NULL;
20588 }
20589
20590
20591 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
20592 PyObject *resultobj;
20593 wxFontList *arg1 = (wxFontList *) 0 ;
20594 int arg2 ;
20595 int arg3 ;
20596 int arg4 ;
20597 int arg5 ;
20598 bool arg6 = (bool) false ;
20599 wxString const &arg7_defvalue = wxPyEmptyString ;
20600 wxString *arg7 = (wxString *) &arg7_defvalue ;
20601 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
20602 wxFont *result;
20603 bool temp7 = false ;
20604 PyObject * obj0 = 0 ;
20605 PyObject * obj1 = 0 ;
20606 PyObject * obj2 = 0 ;
20607 PyObject * obj3 = 0 ;
20608 PyObject * obj4 = 0 ;
20609 PyObject * obj5 = 0 ;
20610 PyObject * obj6 = 0 ;
20611 PyObject * obj7 = 0 ;
20612 char *kwnames[] = {
20613 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
20614 };
20615
20616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20618 if (SWIG_arg_fail(1)) SWIG_fail;
20619 {
20620 arg2 = (int)(SWIG_As_int(obj1));
20621 if (SWIG_arg_fail(2)) SWIG_fail;
20622 }
20623 {
20624 arg3 = (int)(SWIG_As_int(obj2));
20625 if (SWIG_arg_fail(3)) SWIG_fail;
20626 }
20627 {
20628 arg4 = (int)(SWIG_As_int(obj3));
20629 if (SWIG_arg_fail(4)) SWIG_fail;
20630 }
20631 {
20632 arg5 = (int)(SWIG_As_int(obj4));
20633 if (SWIG_arg_fail(5)) SWIG_fail;
20634 }
20635 if (obj5) {
20636 {
20637 arg6 = (bool)(SWIG_As_bool(obj5));
20638 if (SWIG_arg_fail(6)) SWIG_fail;
20639 }
20640 }
20641 if (obj6) {
20642 {
20643 arg7 = wxString_in_helper(obj6);
20644 if (arg7 == NULL) SWIG_fail;
20645 temp7 = true;
20646 }
20647 }
20648 if (obj7) {
20649 {
20650 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
20651 if (SWIG_arg_fail(8)) SWIG_fail;
20652 }
20653 }
20654 {
20655 PyThreadState* __tstate = wxPyBeginAllowThreads();
20656 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
20657
20658 wxPyEndAllowThreads(__tstate);
20659 if (PyErr_Occurred()) SWIG_fail;
20660 }
20661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
20662 {
20663 if (temp7)
20664 delete arg7;
20665 }
20666 return resultobj;
20667 fail:
20668 {
20669 if (temp7)
20670 delete arg7;
20671 }
20672 return NULL;
20673 }
20674
20675
20676 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
20677 PyObject *resultobj;
20678 wxFontList *arg1 = (wxFontList *) 0 ;
20679 wxFont *arg2 = (wxFont *) 0 ;
20680 PyObject * obj0 = 0 ;
20681 PyObject * obj1 = 0 ;
20682 char *kwnames[] = {
20683 (char *) "self",(char *) "font", NULL
20684 };
20685
20686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
20687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20688 if (SWIG_arg_fail(1)) SWIG_fail;
20689 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20690 if (SWIG_arg_fail(2)) SWIG_fail;
20691 {
20692 PyThreadState* __tstate = wxPyBeginAllowThreads();
20693 (arg1)->RemoveFont(arg2);
20694
20695 wxPyEndAllowThreads(__tstate);
20696 if (PyErr_Occurred()) SWIG_fail;
20697 }
20698 Py_INCREF(Py_None); resultobj = Py_None;
20699 return resultobj;
20700 fail:
20701 return NULL;
20702 }
20703
20704
20705 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20706 PyObject *resultobj;
20707 wxFontList *arg1 = (wxFontList *) 0 ;
20708 int result;
20709 PyObject * obj0 = 0 ;
20710 char *kwnames[] = {
20711 (char *) "self", NULL
20712 };
20713
20714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
20715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20716 if (SWIG_arg_fail(1)) SWIG_fail;
20717 {
20718 PyThreadState* __tstate = wxPyBeginAllowThreads();
20719 result = (int)(arg1)->GetCount();
20720
20721 wxPyEndAllowThreads(__tstate);
20722 if (PyErr_Occurred()) SWIG_fail;
20723 }
20724 {
20725 resultobj = SWIG_From_int((int)(result));
20726 }
20727 return resultobj;
20728 fail:
20729 return NULL;
20730 }
20731
20732
20733 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
20734 PyObject *obj;
20735 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20736 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
20737 Py_INCREF(obj);
20738 return Py_BuildValue((char *)"");
20739 }
20740 static int _wrap_TheFontList_set(PyObject *) {
20741 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
20742 return 1;
20743 }
20744
20745
20746 static PyObject *_wrap_TheFontList_get(void) {
20747 PyObject *pyobj;
20748
20749 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
20750 return pyobj;
20751 }
20752
20753
20754 static int _wrap_ThePenList_set(PyObject *) {
20755 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
20756 return 1;
20757 }
20758
20759
20760 static PyObject *_wrap_ThePenList_get(void) {
20761 PyObject *pyobj;
20762
20763 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
20764 return pyobj;
20765 }
20766
20767
20768 static int _wrap_TheBrushList_set(PyObject *) {
20769 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
20770 return 1;
20771 }
20772
20773
20774 static PyObject *_wrap_TheBrushList_get(void) {
20775 PyObject *pyobj;
20776
20777 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
20778 return pyobj;
20779 }
20780
20781
20782 static int _wrap_TheColourDatabase_set(PyObject *) {
20783 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
20784 return 1;
20785 }
20786
20787
20788 static PyObject *_wrap_TheColourDatabase_get(void) {
20789 PyObject *pyobj;
20790
20791 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
20792 return pyobj;
20793 }
20794
20795
20796 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
20797 PyObject *resultobj;
20798 wxEffects *result;
20799 char *kwnames[] = {
20800 NULL
20801 };
20802
20803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
20804 {
20805 PyThreadState* __tstate = wxPyBeginAllowThreads();
20806 result = (wxEffects *)new wxEffects();
20807
20808 wxPyEndAllowThreads(__tstate);
20809 if (PyErr_Occurred()) SWIG_fail;
20810 }
20811 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
20812 return resultobj;
20813 fail:
20814 return NULL;
20815 }
20816
20817
20818 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20819 PyObject *resultobj;
20820 wxEffects *arg1 = (wxEffects *) 0 ;
20821 wxColour result;
20822 PyObject * obj0 = 0 ;
20823 char *kwnames[] = {
20824 (char *) "self", NULL
20825 };
20826
20827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
20828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20829 if (SWIG_arg_fail(1)) SWIG_fail;
20830 {
20831 PyThreadState* __tstate = wxPyBeginAllowThreads();
20832 result = ((wxEffects const *)arg1)->GetHighlightColour();
20833
20834 wxPyEndAllowThreads(__tstate);
20835 if (PyErr_Occurred()) SWIG_fail;
20836 }
20837 {
20838 wxColour * resultptr;
20839 resultptr = new wxColour((wxColour &)(result));
20840 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20841 }
20842 return resultobj;
20843 fail:
20844 return NULL;
20845 }
20846
20847
20848 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20849 PyObject *resultobj;
20850 wxEffects *arg1 = (wxEffects *) 0 ;
20851 wxColour result;
20852 PyObject * obj0 = 0 ;
20853 char *kwnames[] = {
20854 (char *) "self", NULL
20855 };
20856
20857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
20858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20859 if (SWIG_arg_fail(1)) SWIG_fail;
20860 {
20861 PyThreadState* __tstate = wxPyBeginAllowThreads();
20862 result = ((wxEffects const *)arg1)->GetLightShadow();
20863
20864 wxPyEndAllowThreads(__tstate);
20865 if (PyErr_Occurred()) SWIG_fail;
20866 }
20867 {
20868 wxColour * resultptr;
20869 resultptr = new wxColour((wxColour &)(result));
20870 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20871 }
20872 return resultobj;
20873 fail:
20874 return NULL;
20875 }
20876
20877
20878 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20879 PyObject *resultobj;
20880 wxEffects *arg1 = (wxEffects *) 0 ;
20881 wxColour result;
20882 PyObject * obj0 = 0 ;
20883 char *kwnames[] = {
20884 (char *) "self", NULL
20885 };
20886
20887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
20888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20889 if (SWIG_arg_fail(1)) SWIG_fail;
20890 {
20891 PyThreadState* __tstate = wxPyBeginAllowThreads();
20892 result = ((wxEffects const *)arg1)->GetFaceColour();
20893
20894 wxPyEndAllowThreads(__tstate);
20895 if (PyErr_Occurred()) SWIG_fail;
20896 }
20897 {
20898 wxColour * resultptr;
20899 resultptr = new wxColour((wxColour &)(result));
20900 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20901 }
20902 return resultobj;
20903 fail:
20904 return NULL;
20905 }
20906
20907
20908 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20909 PyObject *resultobj;
20910 wxEffects *arg1 = (wxEffects *) 0 ;
20911 wxColour result;
20912 PyObject * obj0 = 0 ;
20913 char *kwnames[] = {
20914 (char *) "self", NULL
20915 };
20916
20917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
20918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20919 if (SWIG_arg_fail(1)) SWIG_fail;
20920 {
20921 PyThreadState* __tstate = wxPyBeginAllowThreads();
20922 result = ((wxEffects const *)arg1)->GetMediumShadow();
20923
20924 wxPyEndAllowThreads(__tstate);
20925 if (PyErr_Occurred()) SWIG_fail;
20926 }
20927 {
20928 wxColour * resultptr;
20929 resultptr = new wxColour((wxColour &)(result));
20930 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20931 }
20932 return resultobj;
20933 fail:
20934 return NULL;
20935 }
20936
20937
20938 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20939 PyObject *resultobj;
20940 wxEffects *arg1 = (wxEffects *) 0 ;
20941 wxColour result;
20942 PyObject * obj0 = 0 ;
20943 char *kwnames[] = {
20944 (char *) "self", NULL
20945 };
20946
20947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
20948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20949 if (SWIG_arg_fail(1)) SWIG_fail;
20950 {
20951 PyThreadState* __tstate = wxPyBeginAllowThreads();
20952 result = ((wxEffects const *)arg1)->GetDarkShadow();
20953
20954 wxPyEndAllowThreads(__tstate);
20955 if (PyErr_Occurred()) SWIG_fail;
20956 }
20957 {
20958 wxColour * resultptr;
20959 resultptr = new wxColour((wxColour &)(result));
20960 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20961 }
20962 return resultobj;
20963 fail:
20964 return NULL;
20965 }
20966
20967
20968 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20969 PyObject *resultobj;
20970 wxEffects *arg1 = (wxEffects *) 0 ;
20971 wxColour *arg2 = 0 ;
20972 wxColour temp2 ;
20973 PyObject * obj0 = 0 ;
20974 PyObject * obj1 = 0 ;
20975 char *kwnames[] = {
20976 (char *) "self",(char *) "c", NULL
20977 };
20978
20979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
20980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20981 if (SWIG_arg_fail(1)) SWIG_fail;
20982 {
20983 arg2 = &temp2;
20984 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20985 }
20986 {
20987 PyThreadState* __tstate = wxPyBeginAllowThreads();
20988 (arg1)->SetHighlightColour((wxColour const &)*arg2);
20989
20990 wxPyEndAllowThreads(__tstate);
20991 if (PyErr_Occurred()) SWIG_fail;
20992 }
20993 Py_INCREF(Py_None); resultobj = Py_None;
20994 return resultobj;
20995 fail:
20996 return NULL;
20997 }
20998
20999
21000 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21001 PyObject *resultobj;
21002 wxEffects *arg1 = (wxEffects *) 0 ;
21003 wxColour *arg2 = 0 ;
21004 wxColour temp2 ;
21005 PyObject * obj0 = 0 ;
21006 PyObject * obj1 = 0 ;
21007 char *kwnames[] = {
21008 (char *) "self",(char *) "c", NULL
21009 };
21010
21011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
21012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21013 if (SWIG_arg_fail(1)) SWIG_fail;
21014 {
21015 arg2 = &temp2;
21016 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21017 }
21018 {
21019 PyThreadState* __tstate = wxPyBeginAllowThreads();
21020 (arg1)->SetLightShadow((wxColour const &)*arg2);
21021
21022 wxPyEndAllowThreads(__tstate);
21023 if (PyErr_Occurred()) SWIG_fail;
21024 }
21025 Py_INCREF(Py_None); resultobj = Py_None;
21026 return resultobj;
21027 fail:
21028 return NULL;
21029 }
21030
21031
21032 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
21033 PyObject *resultobj;
21034 wxEffects *arg1 = (wxEffects *) 0 ;
21035 wxColour *arg2 = 0 ;
21036 wxColour temp2 ;
21037 PyObject * obj0 = 0 ;
21038 PyObject * obj1 = 0 ;
21039 char *kwnames[] = {
21040 (char *) "self",(char *) "c", NULL
21041 };
21042
21043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
21044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21045 if (SWIG_arg_fail(1)) SWIG_fail;
21046 {
21047 arg2 = &temp2;
21048 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21049 }
21050 {
21051 PyThreadState* __tstate = wxPyBeginAllowThreads();
21052 (arg1)->SetFaceColour((wxColour const &)*arg2);
21053
21054 wxPyEndAllowThreads(__tstate);
21055 if (PyErr_Occurred()) SWIG_fail;
21056 }
21057 Py_INCREF(Py_None); resultobj = Py_None;
21058 return resultobj;
21059 fail:
21060 return NULL;
21061 }
21062
21063
21064 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21065 PyObject *resultobj;
21066 wxEffects *arg1 = (wxEffects *) 0 ;
21067 wxColour *arg2 = 0 ;
21068 wxColour temp2 ;
21069 PyObject * obj0 = 0 ;
21070 PyObject * obj1 = 0 ;
21071 char *kwnames[] = {
21072 (char *) "self",(char *) "c", NULL
21073 };
21074
21075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
21076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21077 if (SWIG_arg_fail(1)) SWIG_fail;
21078 {
21079 arg2 = &temp2;
21080 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21081 }
21082 {
21083 PyThreadState* __tstate = wxPyBeginAllowThreads();
21084 (arg1)->SetMediumShadow((wxColour const &)*arg2);
21085
21086 wxPyEndAllowThreads(__tstate);
21087 if (PyErr_Occurred()) SWIG_fail;
21088 }
21089 Py_INCREF(Py_None); resultobj = Py_None;
21090 return resultobj;
21091 fail:
21092 return NULL;
21093 }
21094
21095
21096 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21097 PyObject *resultobj;
21098 wxEffects *arg1 = (wxEffects *) 0 ;
21099 wxColour *arg2 = 0 ;
21100 wxColour temp2 ;
21101 PyObject * obj0 = 0 ;
21102 PyObject * obj1 = 0 ;
21103 char *kwnames[] = {
21104 (char *) "self",(char *) "c", NULL
21105 };
21106
21107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
21108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21109 if (SWIG_arg_fail(1)) SWIG_fail;
21110 {
21111 arg2 = &temp2;
21112 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21113 }
21114 {
21115 PyThreadState* __tstate = wxPyBeginAllowThreads();
21116 (arg1)->SetDarkShadow((wxColour const &)*arg2);
21117
21118 wxPyEndAllowThreads(__tstate);
21119 if (PyErr_Occurred()) SWIG_fail;
21120 }
21121 Py_INCREF(Py_None); resultobj = Py_None;
21122 return resultobj;
21123 fail:
21124 return NULL;
21125 }
21126
21127
21128 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
21129 PyObject *resultobj;
21130 wxEffects *arg1 = (wxEffects *) 0 ;
21131 wxColour *arg2 = 0 ;
21132 wxColour *arg3 = 0 ;
21133 wxColour *arg4 = 0 ;
21134 wxColour *arg5 = 0 ;
21135 wxColour *arg6 = 0 ;
21136 wxColour temp2 ;
21137 wxColour temp3 ;
21138 wxColour temp4 ;
21139 wxColour temp5 ;
21140 wxColour temp6 ;
21141 PyObject * obj0 = 0 ;
21142 PyObject * obj1 = 0 ;
21143 PyObject * obj2 = 0 ;
21144 PyObject * obj3 = 0 ;
21145 PyObject * obj4 = 0 ;
21146 PyObject * obj5 = 0 ;
21147 char *kwnames[] = {
21148 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
21149 };
21150
21151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
21152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21153 if (SWIG_arg_fail(1)) SWIG_fail;
21154 {
21155 arg2 = &temp2;
21156 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21157 }
21158 {
21159 arg3 = &temp3;
21160 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
21161 }
21162 {
21163 arg4 = &temp4;
21164 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
21165 }
21166 {
21167 arg5 = &temp5;
21168 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
21169 }
21170 {
21171 arg6 = &temp6;
21172 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
21173 }
21174 {
21175 PyThreadState* __tstate = wxPyBeginAllowThreads();
21176 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
21177
21178 wxPyEndAllowThreads(__tstate);
21179 if (PyErr_Occurred()) SWIG_fail;
21180 }
21181 Py_INCREF(Py_None); resultobj = Py_None;
21182 return resultobj;
21183 fail:
21184 return NULL;
21185 }
21186
21187
21188 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
21189 PyObject *resultobj;
21190 wxEffects *arg1 = (wxEffects *) 0 ;
21191 wxDC *arg2 = 0 ;
21192 wxRect *arg3 = 0 ;
21193 int arg4 = (int) 1 ;
21194 wxRect temp3 ;
21195 PyObject * obj0 = 0 ;
21196 PyObject * obj1 = 0 ;
21197 PyObject * obj2 = 0 ;
21198 PyObject * obj3 = 0 ;
21199 char *kwnames[] = {
21200 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
21201 };
21202
21203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21205 if (SWIG_arg_fail(1)) SWIG_fail;
21206 {
21207 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21208 if (SWIG_arg_fail(2)) SWIG_fail;
21209 if (arg2 == NULL) {
21210 SWIG_null_ref("wxDC");
21211 }
21212 if (SWIG_arg_fail(2)) SWIG_fail;
21213 }
21214 {
21215 arg3 = &temp3;
21216 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
21217 }
21218 if (obj3) {
21219 {
21220 arg4 = (int)(SWIG_As_int(obj3));
21221 if (SWIG_arg_fail(4)) SWIG_fail;
21222 }
21223 }
21224 {
21225 PyThreadState* __tstate = wxPyBeginAllowThreads();
21226 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
21227
21228 wxPyEndAllowThreads(__tstate);
21229 if (PyErr_Occurred()) SWIG_fail;
21230 }
21231 Py_INCREF(Py_None); resultobj = Py_None;
21232 return resultobj;
21233 fail:
21234 return NULL;
21235 }
21236
21237
21238 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
21239 PyObject *resultobj;
21240 wxEffects *arg1 = (wxEffects *) 0 ;
21241 wxRect *arg2 = 0 ;
21242 wxDC *arg3 = 0 ;
21243 wxBitmap *arg4 = 0 ;
21244 bool result;
21245 wxRect temp2 ;
21246 PyObject * obj0 = 0 ;
21247 PyObject * obj1 = 0 ;
21248 PyObject * obj2 = 0 ;
21249 PyObject * obj3 = 0 ;
21250 char *kwnames[] = {
21251 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
21252 };
21253
21254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21256 if (SWIG_arg_fail(1)) SWIG_fail;
21257 {
21258 arg2 = &temp2;
21259 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
21260 }
21261 {
21262 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21263 if (SWIG_arg_fail(3)) SWIG_fail;
21264 if (arg3 == NULL) {
21265 SWIG_null_ref("wxDC");
21266 }
21267 if (SWIG_arg_fail(3)) SWIG_fail;
21268 }
21269 {
21270 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
21271 if (SWIG_arg_fail(4)) SWIG_fail;
21272 if (arg4 == NULL) {
21273 SWIG_null_ref("wxBitmap");
21274 }
21275 if (SWIG_arg_fail(4)) SWIG_fail;
21276 }
21277 {
21278 PyThreadState* __tstate = wxPyBeginAllowThreads();
21279 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
21280
21281 wxPyEndAllowThreads(__tstate);
21282 if (PyErr_Occurred()) SWIG_fail;
21283 }
21284 {
21285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21286 }
21287 return resultobj;
21288 fail:
21289 return NULL;
21290 }
21291
21292
21293 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
21294 PyObject *obj;
21295 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21296 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
21297 Py_INCREF(obj);
21298 return Py_BuildValue((char *)"");
21299 }
21300 static PyMethodDef SwigMethods[] = {
21301 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
21302 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
21303 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
21304 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
21305 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
21306 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
21307 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
21308 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
21309 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21310 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
21311 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
21312 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
21313 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
21314 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21315 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21316 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21317 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
21318 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21319 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21320 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21321 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21322 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21323 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
21324 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
21325 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
21326 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21327 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21328 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
21329 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21330 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
21331 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
21332 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
21333 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
21334 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21335 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
21336 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21337 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21338 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21339 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
21340 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21341 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
21342 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21343 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21344 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21345 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21346 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21347 { (char *)"Pen_GetDashCount", (PyCFunction) _wrap_Pen_GetDashCount, METH_VARARGS | METH_KEYWORDS, NULL},
21348 { (char *)"Pen_GetStipple", (PyCFunction) _wrap_Pen_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21349 { (char *)"Pen_SetStipple", (PyCFunction) _wrap_Pen_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21350 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21351 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21352 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
21353 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
21354 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
21355 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21356 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21357 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21358 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21359 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21360 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21361 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
21362 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21363 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
21364 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21365 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21366 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21367 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21368 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
21369 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
21370 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
21371 { (char *)"Bitmap_GetHandle", (PyCFunction) _wrap_Bitmap_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21372 { (char *)"Bitmap_SetHandle", (PyCFunction) _wrap_Bitmap_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21373 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21374 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21375 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21376 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21377 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21378 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
21379 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
21380 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
21381 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
21382 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21383 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
21384 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
21385 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21386 { (char *)"Bitmap_SetPalette", (PyCFunction) _wrap_Bitmap_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21387 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21388 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21389 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21390 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21391 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21392 { (char *)"Bitmap_CopyFromCursor", (PyCFunction) _wrap_Bitmap_CopyFromCursor, METH_VARARGS | METH_KEYWORDS, NULL},
21393 { (char *)"Bitmap_GetQuality", (PyCFunction) _wrap_Bitmap_GetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
21394 { (char *)"Bitmap_SetQuality", (PyCFunction) _wrap_Bitmap_SetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
21395 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21396 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21397 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
21398 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
21399 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
21400 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
21401 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
21402 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21403 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21404 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21405 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
21406 { (char *)"Icon_LoadFile", (PyCFunction) _wrap_Icon_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
21407 { (char *)"Icon_GetHandle", (PyCFunction) _wrap_Icon_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21408 { (char *)"Icon_SetHandle", (PyCFunction) _wrap_Icon_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21409 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21410 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21411 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21412 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21413 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21414 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21415 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21416 { (char *)"Icon_SetSize", (PyCFunction) _wrap_Icon_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21417 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21418 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
21419 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21420 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21421 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21422 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21423 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21424 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
21425 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
21426 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
21427 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
21428 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
21429 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21430 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
21431 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21432 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
21433 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21434 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
21435 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
21436 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
21437 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
21438 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
21439 { (char *)"Cursor_GetHandle", (PyCFunction) _wrap_Cursor_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21440 { (char *)"Cursor_SetHandle", (PyCFunction) _wrap_Cursor_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21441 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21442 { (char *)"Cursor_GetWidth", (PyCFunction) _wrap_Cursor_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21443 { (char *)"Cursor_GetHeight", (PyCFunction) _wrap_Cursor_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21444 { (char *)"Cursor_GetDepth", (PyCFunction) _wrap_Cursor_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21445 { (char *)"Cursor_SetWidth", (PyCFunction) _wrap_Cursor_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21446 { (char *)"Cursor_SetHeight", (PyCFunction) _wrap_Cursor_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21447 { (char *)"Cursor_SetDepth", (PyCFunction) _wrap_Cursor_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21448 { (char *)"Cursor_SetSize", (PyCFunction) _wrap_Cursor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21449 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
21450 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
21451 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21452 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
21453 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
21454 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
21455 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21456 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
21457 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
21458 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21459 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
21460 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
21461 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
21462 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
21463 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
21464 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21465 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
21466 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
21467 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
21468 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21469 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
21470 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
21471 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21472 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
21473 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
21474 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21475 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21476 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21477 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
21478 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
21479 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
21480 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
21481 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
21482 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
21483 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
21484 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21485 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
21486 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21487 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
21488 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
21489 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
21490 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
21491 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
21492 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
21493 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21494 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21495 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21496 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
21497 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21498 { (char *)"NativeFontInfo_GetPixelSize", (PyCFunction) _wrap_NativeFontInfo_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21499 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21500 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21501 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21502 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21503 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21504 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21505 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21506 { (char *)"NativeFontInfo_SetPixelSize", (PyCFunction) _wrap_NativeFontInfo_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21507 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21508 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21509 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21510 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21511 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21512 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21513 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
21514 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
21515 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
21516 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21517 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21518 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
21519 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
21520 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
21521 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
21522 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
21523 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21524 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21525 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
21526 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
21527 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
21528 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21529 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21530 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21531 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21532 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21533 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21534 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21535 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
21536 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21537 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21538 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
21539 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
21540 { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
21541 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21542 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21543 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21544 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
21545 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
21546 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
21547 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
21548 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21549 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21550 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21551 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
21552 { (char *)"new_Font2", (PyCFunction) _wrap_new_Font2, METH_VARARGS | METH_KEYWORDS, NULL},
21553 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21554 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21555 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21556 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21557 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21558 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21559 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
21560 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21561 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21562 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21563 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21564 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21565 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21566 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21567 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21568 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21569 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21570 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21571 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21572 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21573 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21574 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21575 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21576 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21577 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21578 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21579 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
21580 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21581 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
21582 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
21583 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
21584 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21585 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21586 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21587 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21588 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
21589 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21590 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21591 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21592 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21593 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21594 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21595 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21596 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
21597 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
21598 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
21599 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
21600 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
21601 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
21602 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
21603 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
21604 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21605 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21606 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
21607 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
21608 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21609 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21610 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21611 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21612 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21613 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21614 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
21615 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
21616 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
21617 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
21618 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
21619 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21620 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
21621 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21622 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21623 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
21624 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
21625 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
21626 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21627 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
21628 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21629 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21630 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21631 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
21632 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21633 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21634 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
21635 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
21636 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
21637 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21638 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21639 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
21640 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21641 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21642 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21643 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
21644 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21645 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
21646 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21647 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
21648 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21649 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
21650 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
21651 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
21652 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21653 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21654 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21655 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21656 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21657 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21658 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21659 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21660 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21661 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
21662 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21663 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
21664 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
21665 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21666 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21667 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21668 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21669 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21670 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
21671 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21672 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
21673 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21674 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
21675 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21676 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21677 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21678 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21679 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21680 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
21681 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
21682 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21683 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21684 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
21685 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21686 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21687 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21688 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
21689 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
21690 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21691 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21692 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21693 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21694 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21695 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21696 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21697 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21698 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21699 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21700 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21701 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21702 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21703 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21704 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
21705 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21706 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21707 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
21708 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21709 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
21710 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
21711 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21712 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21713 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
21714 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
21715 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21716 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21717 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21718 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21719 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21720 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
21721 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21722 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21723 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21724 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21725 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21726 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21727 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21728 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21729 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21730 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21731 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21732 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21733 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21734 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21735 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21736 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21737 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21738 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21739 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21740 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21741 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21742 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21743 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21744 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21745 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
21746 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21747 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21748 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21749 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21750 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21751 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21752 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
21753 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
21754 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
21755 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
21756 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21757 { (char *)"DC_GetHDC", (PyCFunction) _wrap_DC_GetHDC, METH_VARARGS | METH_KEYWORDS, NULL},
21758 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
21759 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
21760 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
21761 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
21762 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
21763 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
21764 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
21765 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
21766 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
21767 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
21768 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
21769 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
21770 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
21771 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
21772 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
21773 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21774 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
21775 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
21776 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
21777 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21778 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21779 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
21780 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
21781 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
21782 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21783 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
21784 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
21785 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
21786 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
21787 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
21788 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
21789 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21790 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21791 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21792 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21793 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
21794 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21795 { (char *)"delete_MetaFile", (PyCFunction) _wrap_delete_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21796 { (char *)"MetaFile_Ok", (PyCFunction) _wrap_MetaFile_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21797 { (char *)"MetaFile_SetClipboard", (PyCFunction) _wrap_MetaFile_SetClipboard, METH_VARARGS | METH_KEYWORDS, NULL},
21798 { (char *)"MetaFile_GetSize", (PyCFunction) _wrap_MetaFile_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21799 { (char *)"MetaFile_GetWidth", (PyCFunction) _wrap_MetaFile_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21800 { (char *)"MetaFile_GetHeight", (PyCFunction) _wrap_MetaFile_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21801 { (char *)"MetaFile_GetFileName", (PyCFunction) _wrap_MetaFile_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21802 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
21803 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
21804 { (char *)"MetaFileDC_Close", (PyCFunction) _wrap_MetaFileDC_Close, METH_VARARGS | METH_KEYWORDS, NULL},
21805 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
21806 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
21807 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
21808 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21809 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21810 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
21811 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
21812 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21813 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
21814 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
21815 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
21816 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
21817 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
21818 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21819 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
21820 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
21821 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
21822 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
21823 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21824 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
21825 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21826 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21827 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21828 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21829 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
21830 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21831 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21832 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
21833 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
21834 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
21835 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
21836 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
21837 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
21838 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
21839 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
21840 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21841 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
21842 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
21843 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21844 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21845 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21846 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21847 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21848 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21849 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21850 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21851 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21852 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21853 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21854 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
21855 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21856 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
21857 { NULL, NULL, 0, NULL }
21858 };
21859
21860
21861 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21862
21863 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
21864 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
21865 }
21866 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
21867 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
21868 }
21869 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
21870 return (void *)((wxGDIObject *) ((wxIcon *) x));
21871 }
21872 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
21873 return (void *)((wxGDIObject *) ((wxPalette *) x));
21874 }
21875 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
21876 return (void *)((wxGDIObject *) ((wxPen *) x));
21877 }
21878 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
21879 return (void *)((wxGDIObject *) ((wxFont *) x));
21880 }
21881 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
21882 return (void *)((wxGDIObject *) ((wxCursor *) x));
21883 }
21884 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
21885 return (void *)((wxGDIObject *) ((wxBitmap *) x));
21886 }
21887 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
21888 return (void *)((wxGDIObject *) ((wxRegion *) x));
21889 }
21890 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
21891 return (void *)((wxGDIObject *) ((wxBrush *) x));
21892 }
21893 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
21894 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
21895 }
21896 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
21897 return (void *)((wxDC *) ((wxScreenDC *) x));
21898 }
21899 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
21900 return (void *)((wxDC *) ((wxMirrorDC *) x));
21901 }
21902 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
21903 return (void *)((wxDC *) ((wxMemoryDC *) x));
21904 }
21905 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
21906 return (void *)((wxDC *) ((wxWindowDC *) x));
21907 }
21908 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
21909 return (void *)((wxDC *) ((wxMetaFileDC *) x));
21910 }
21911 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
21912 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21913 }
21914 static void *_p_wxClientDCTo_p_wxDC(void *x) {
21915 return (void *)((wxDC *) ((wxClientDC *) x));
21916 }
21917 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
21918 return (void *)((wxDC *) ((wxPaintDC *) x));
21919 }
21920 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
21921 return (void *)((wxDC *) ((wxPostScriptDC *) x));
21922 }
21923 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
21924 return (void *)((wxDC *) ((wxPrinterDC *) x));
21925 }
21926 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
21927 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
21928 }
21929 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21930 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21931 }
21932 static void *_p_wxPenTo_p_wxObject(void *x) {
21933 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
21934 }
21935 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
21936 return (void *)((wxObject *) ((wxRegionIterator *) x));
21937 }
21938 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21939 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21940 }
21941 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21942 return (void *)((wxObject *) ((wxSizerItem *) x));
21943 }
21944 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
21945 return (void *)((wxObject *) ((wxColourDatabase *) x));
21946 }
21947 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21948 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21949 }
21950 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21951 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21952 }
21953 static void *_p_wxIconTo_p_wxObject(void *x) {
21954 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
21955 }
21956 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21957 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21958 }
21959 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21960 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21961 }
21962 static void *_p_wxSizerTo_p_wxObject(void *x) {
21963 return (void *)((wxObject *) ((wxSizer *) x));
21964 }
21965 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21966 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21967 }
21968 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21969 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21970 }
21971 static void *_p_wxPenListTo_p_wxObject(void *x) {
21972 return (void *)((wxObject *) ((wxPenList *) x));
21973 }
21974 static void *_p_wxEventTo_p_wxObject(void *x) {
21975 return (void *)((wxObject *) ((wxEvent *) x));
21976 }
21977 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21978 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21979 }
21980 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21981 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21982 }
21983 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21984 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21985 }
21986 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21987 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21988 }
21989 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21990 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21991 }
21992 static void *_p_wxDCTo_p_wxObject(void *x) {
21993 return (void *)((wxObject *) ((wxDC *) x));
21994 }
21995 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21996 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21997 }
21998 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21999 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
22000 }
22001 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
22002 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
22003 }
22004 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
22005 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
22006 }
22007 static void *_p_wxControlTo_p_wxObject(void *x) {
22008 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
22009 }
22010 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
22011 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
22012 }
22013 static void *_p_wxClientDCTo_p_wxObject(void *x) {
22014 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
22015 }
22016 static void *_p_wxFSFileTo_p_wxObject(void *x) {
22017 return (void *)((wxObject *) ((wxFSFile *) x));
22018 }
22019 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
22020 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
22021 }
22022 static void *_p_wxRegionTo_p_wxObject(void *x) {
22023 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
22024 }
22025 static void *_p_wxPySizerTo_p_wxObject(void *x) {
22026 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
22027 }
22028 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
22029 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
22030 }
22031 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
22032 return (void *)((wxObject *) ((wxGDIObject *) x));
22033 }
22034 static void *_p_wxEffectsTo_p_wxObject(void *x) {
22035 return (void *)((wxObject *) ((wxEffects *) x));
22036 }
22037 static void *_p_wxPyEventTo_p_wxObject(void *x) {
22038 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
22039 }
22040 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
22041 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
22042 }
22043 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
22044 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
22045 }
22046 static void *_p_wxShowEventTo_p_wxObject(void *x) {
22047 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
22048 }
22049 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
22050 return (void *)((wxObject *) ((wxMenuItem *) x));
22051 }
22052 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
22053 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
22054 }
22055 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
22056 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
22057 }
22058 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
22059 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
22060 }
22061 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
22062 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
22063 }
22064 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
22065 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
22066 }
22067 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
22068 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
22069 }
22070 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
22071 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
22072 }
22073 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
22074 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
22075 }
22076 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
22077 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
22078 }
22079 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
22080 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
22081 }
22082 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
22083 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
22084 }
22085 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
22086 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
22087 }
22088 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
22089 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
22090 }
22091 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
22092 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
22093 }
22094 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
22095 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
22096 }
22097 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
22098 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
22099 }
22100 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
22101 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
22102 }
22103 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
22104 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
22105 }
22106 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
22107 return (void *)((wxObject *) ((wxImageHandler *) x));
22108 }
22109 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
22110 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
22111 }
22112 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
22113 return (void *)((wxObject *) ((wxEvtHandler *) x));
22114 }
22115 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
22116 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
22117 }
22118 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
22119 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
22120 }
22121 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
22122 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
22123 }
22124 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
22125 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
22126 }
22127 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
22128 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
22129 }
22130 static void *_p_wxImageTo_p_wxObject(void *x) {
22131 return (void *)((wxObject *) ((wxImage *) x));
22132 }
22133 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
22134 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
22135 }
22136 static void *_p_wxPaletteTo_p_wxObject(void *x) {
22137 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
22138 }
22139 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
22140 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
22141 }
22142 static void *_p_wxImageListTo_p_wxObject(void *x) {
22143 return (void *)((wxObject *) ((wxImageList *) x));
22144 }
22145 static void *_p_wxCursorTo_p_wxObject(void *x) {
22146 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
22147 }
22148 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
22149 return (void *)((wxObject *) ((wxEncodingConverter *) x));
22150 }
22151 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
22152 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
22153 }
22154 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
22155 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
22156 }
22157 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
22158 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
22159 }
22160 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
22161 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
22162 }
22163 static void *_p_wxWindowTo_p_wxObject(void *x) {
22164 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
22165 }
22166 static void *_p_wxMenuTo_p_wxObject(void *x) {
22167 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
22168 }
22169 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
22170 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
22171 }
22172 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
22173 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
22174 }
22175 static void *_p_wxBrushListTo_p_wxObject(void *x) {
22176 return (void *)((wxObject *) ((wxBrushList *) x));
22177 }
22178 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
22179 return (void *)((wxObject *) ((wxFileSystem *) x));
22180 }
22181 static void *_p_wxBitmapTo_p_wxObject(void *x) {
22182 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
22183 }
22184 static void *_p_wxMaskTo_p_wxObject(void *x) {
22185 return (void *)((wxObject *) ((wxMask *) x));
22186 }
22187 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
22188 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
22189 }
22190 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
22191 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
22192 }
22193 static void *_p_wxPyAppTo_p_wxObject(void *x) {
22194 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
22195 }
22196 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
22197 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
22198 }
22199 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
22200 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
22201 }
22202 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
22203 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
22204 }
22205 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
22206 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
22207 }
22208 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
22209 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
22210 }
22211 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
22212 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
22213 }
22214 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
22215 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
22216 }
22217 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
22218 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
22219 }
22220 static void *_p_wxFontTo_p_wxObject(void *x) {
22221 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
22222 }
22223 static void *_p_wxBrushTo_p_wxObject(void *x) {
22224 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
22225 }
22226 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
22227 return (void *)((wxObject *) ((wxMetaFile *) x));
22228 }
22229 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
22230 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
22231 }
22232 static void *_p_wxColourTo_p_wxObject(void *x) {
22233 return (void *)((wxObject *) ((wxColour *) x));
22234 }
22235 static void *_p_wxFontListTo_p_wxObject(void *x) {
22236 return (void *)((wxObject *) ((wxFontList *) x));
22237 }
22238 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
22239 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
22240 }
22241 static void *_p_wxValidatorTo_p_wxObject(void *x) {
22242 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
22243 }
22244 static void *_p_wxControlTo_p_wxWindow(void *x) {
22245 return (void *)((wxWindow *) ((wxControl *) x));
22246 }
22247 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
22248 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
22249 }
22250 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
22251 return (void *)((wxWindow *) ((wxMenuBar *) x));
22252 }
22253 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}};
22254 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}};
22255 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}};
22256 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}};
22257 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}};
22258 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}};
22259 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}};
22260 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}};
22261 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}};
22262 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}};
22263 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}};
22264 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}};
22265 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}};
22266 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}};
22267 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}};
22268 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}};
22269 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}};
22270 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}};
22271 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}};
22272 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}};
22273 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}};
22274 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}};
22275 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}};
22276 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxRegionIterator", _p_wxRegionIteratorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPen", _p_wxPenTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColourDatabase", _p_wxColourDatabaseTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPenList", _p_wxPenListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMask", _p_wxMaskTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFont", _p_wxFontTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClientDC", _p_wxClientDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMemoryDC", _p_wxMemoryDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxRegion", _p_wxRegionTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDC", _p_wxDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIcon", _p_wxIconTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDC", _p_wxWindowDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGDIObject", _p_wxGDIObjectTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEffects", _p_wxEffectsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPostScriptDC", _p_wxPostScriptDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintDC", _p_wxPaintDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBufferedPaintDC", _p_wxBufferedPaintDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrinterDC", _p_wxPrinterDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScreenDC", _p_wxScreenDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_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}};
22277 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}};
22278 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}};
22279 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}};
22280 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}};
22281 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}};
22282 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}};
22283 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}};
22284 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}};
22285 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}};
22286 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}};
22287 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}};
22288 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}};
22289 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}};
22290 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}};
22291 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}};
22292 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}};
22293 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}};
22294 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}};
22295 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}};
22296 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}};
22297 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}};
22298 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}};
22299 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}};
22300 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}};
22301 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}};
22302 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}};
22303 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}};
22304 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}};
22305 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}};
22306 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}};
22307 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}};
22308 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}};
22309 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}};
22310 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}};
22311 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}};
22312 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}};
22313 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}};
22314 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}};
22315
22316 static swig_type_info *swig_types_initial[] = {
22317 _swigt__p_wxPostScriptDC,
22318 _swigt__p_wxBrush,
22319 _swigt__p_wxColour,
22320 _swigt__p_wxDC,
22321 _swigt__p_wxMirrorDC,
22322 _swigt__p_form_ops_t,
22323 _swigt__p_wxDuplexMode,
22324 _swigt__p_wxPyFontEnumerator,
22325 _swigt__p_char,
22326 _swigt__p_wxIconLocation,
22327 _swigt__p_wxImage,
22328 _swigt__p_wxMetaFileDC,
22329 _swigt__p_wxMask,
22330 _swigt__p_wxSize,
22331 _swigt__p_wxFont,
22332 _swigt__p_wxWindow,
22333 _swigt__p_double,
22334 _swigt__p_wxMemoryDC,
22335 _swigt__p_wxFontMapper,
22336 _swigt__p_wxEffects,
22337 _swigt__p_wxNativeEncodingInfo,
22338 _swigt__p_wxPalette,
22339 _swigt__p_wxBitmap,
22340 _swigt__p_wxObject,
22341 _swigt__p_wxRegionIterator,
22342 _swigt__p_wxRect,
22343 _swigt__p_wxPaperSize,
22344 _swigt__p_wxString,
22345 _swigt__unsigned_int,
22346 _swigt__p_unsigned_int,
22347 _swigt__p_wxPrinterDC,
22348 _swigt__p_wxIconBundle,
22349 _swigt__p_wxPoint,
22350 _swigt__p_wxDash,
22351 _swigt__p_wxScreenDC,
22352 _swigt__p_wxCursor,
22353 _swigt__p_wxClientDC,
22354 _swigt__p_wxBufferedDC,
22355 _swigt__p_wxImageList,
22356 _swigt__p_unsigned_char,
22357 _swigt__p_wxGDIObject,
22358 _swigt__p_wxIcon,
22359 _swigt__p_wxLocale,
22360 _swigt__ptrdiff_t,
22361 _swigt__std__ptrdiff_t,
22362 _swigt__p_wxRegion,
22363 _swigt__p_wxConfigBase,
22364 _swigt__p_wxLanguageInfo,
22365 _swigt__p_wxWindowDC,
22366 _swigt__p_wxPrintData,
22367 _swigt__p_wxBrushList,
22368 _swigt__p_wxFontList,
22369 _swigt__p_wxPen,
22370 _swigt__p_wxBufferedPaintDC,
22371 _swigt__p_wxPaintDC,
22372 _swigt__p_wxPenList,
22373 _swigt__p_int,
22374 _swigt__p_wxMetaFile,
22375 _swigt__p_unsigned_long,
22376 _swigt__p_wxNativeFontInfo,
22377 _swigt__p_wxEncodingConverter,
22378 _swigt__p_wxColourDatabase,
22379 0
22380 };
22381
22382
22383 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22384
22385 static swig_const_info swig_const_table[] = {
22386 {0, 0, 0, 0.0, 0, 0}};
22387
22388 #ifdef __cplusplus
22389 }
22390 #endif
22391
22392
22393 #ifdef __cplusplus
22394 extern "C" {
22395 #endif
22396
22397 /* Python-specific SWIG API */
22398 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22399 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22400 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22401
22402 /* -----------------------------------------------------------------------------
22403 * global variable support code.
22404 * ----------------------------------------------------------------------------- */
22405
22406 typedef struct swig_globalvar {
22407 char *name; /* Name of global variable */
22408 PyObject *(*get_attr)(); /* Return the current value */
22409 int (*set_attr)(PyObject *); /* Set the value */
22410 struct swig_globalvar *next;
22411 } swig_globalvar;
22412
22413 typedef struct swig_varlinkobject {
22414 PyObject_HEAD
22415 swig_globalvar *vars;
22416 } swig_varlinkobject;
22417
22418 static PyObject *
22419 swig_varlink_repr(swig_varlinkobject *v) {
22420 v = v;
22421 return PyString_FromString("<Swig global variables>");
22422 }
22423
22424 static int
22425 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
22426 swig_globalvar *var;
22427 flags = flags;
22428 fprintf(fp,"Swig global variables { ");
22429 for (var = v->vars; var; var=var->next) {
22430 fprintf(fp,"%s", var->name);
22431 if (var->next) fprintf(fp,", ");
22432 }
22433 fprintf(fp," }\n");
22434 return 0;
22435 }
22436
22437 static PyObject *
22438 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
22439 swig_globalvar *var = v->vars;
22440 while (var) {
22441 if (strcmp(var->name,n) == 0) {
22442 return (*var->get_attr)();
22443 }
22444 var = var->next;
22445 }
22446 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22447 return NULL;
22448 }
22449
22450 static int
22451 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22452 swig_globalvar *var = v->vars;
22453 while (var) {
22454 if (strcmp(var->name,n) == 0) {
22455 return (*var->set_attr)(p);
22456 }
22457 var = var->next;
22458 }
22459 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22460 return 1;
22461 }
22462
22463 static PyTypeObject varlinktype = {
22464 PyObject_HEAD_INIT(0)
22465 0, /* Number of items in variable part (ob_size) */
22466 (char *)"swigvarlink", /* Type name (tp_name) */
22467 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
22468 0, /* Itemsize (tp_itemsize) */
22469 0, /* Deallocator (tp_dealloc) */
22470 (printfunc) swig_varlink_print, /* Print (tp_print) */
22471 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
22472 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
22473 0, /* tp_compare */
22474 (reprfunc) swig_varlink_repr, /* tp_repr */
22475 0, /* tp_as_number */
22476 0, /* tp_as_sequence */
22477 0, /* tp_as_mapping */
22478 0, /* tp_hash */
22479 0, /* tp_call */
22480 0, /* tp_str */
22481 0, /* tp_getattro */
22482 0, /* tp_setattro */
22483 0, /* tp_as_buffer */
22484 0, /* tp_flags */
22485 0, /* tp_doc */
22486 #if PY_VERSION_HEX >= 0x02000000
22487 0, /* tp_traverse */
22488 0, /* tp_clear */
22489 #endif
22490 #if PY_VERSION_HEX >= 0x02010000
22491 0, /* tp_richcompare */
22492 0, /* tp_weaklistoffset */
22493 #endif
22494 #if PY_VERSION_HEX >= 0x02020000
22495 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22496 #endif
22497 #if PY_VERSION_HEX >= 0x02030000
22498 0, /* tp_del */
22499 #endif
22500 #ifdef COUNT_ALLOCS
22501 0,0,0,0 /* tp_alloc -> tp_next */
22502 #endif
22503 };
22504
22505 /* Create a variable linking object for use later */
22506 static PyObject *
22507 SWIG_Python_newvarlink(void) {
22508 swig_varlinkobject *result = 0;
22509 result = PyMem_NEW(swig_varlinkobject,1);
22510 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
22511 result->ob_type = &varlinktype;
22512 result->vars = 0;
22513 result->ob_refcnt = 0;
22514 Py_XINCREF((PyObject *) result);
22515 return ((PyObject*) result);
22516 }
22517
22518 static void
22519 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22520 swig_varlinkobject *v;
22521 swig_globalvar *gv;
22522 v= (swig_varlinkobject *) p;
22523 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22524 gv->name = (char *) malloc(strlen(name)+1);
22525 strcpy(gv->name,name);
22526 gv->get_attr = get_attr;
22527 gv->set_attr = set_attr;
22528 gv->next = v->vars;
22529 v->vars = gv;
22530 }
22531
22532 /* -----------------------------------------------------------------------------
22533 * constants/methods manipulation
22534 * ----------------------------------------------------------------------------- */
22535
22536 /* Install Constants */
22537 static void
22538 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22539 PyObject *obj = 0;
22540 size_t i;
22541 for (i = 0; constants[i].type; i++) {
22542 switch(constants[i].type) {
22543 case SWIG_PY_INT:
22544 obj = PyInt_FromLong(constants[i].lvalue);
22545 break;
22546 case SWIG_PY_FLOAT:
22547 obj = PyFloat_FromDouble(constants[i].dvalue);
22548 break;
22549 case SWIG_PY_STRING:
22550 if (constants[i].pvalue) {
22551 obj = PyString_FromString((char *) constants[i].pvalue);
22552 } else {
22553 Py_INCREF(Py_None);
22554 obj = Py_None;
22555 }
22556 break;
22557 case SWIG_PY_POINTER:
22558 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22559 break;
22560 case SWIG_PY_BINARY:
22561 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22562 break;
22563 default:
22564 obj = 0;
22565 break;
22566 }
22567 if (obj) {
22568 PyDict_SetItemString(d,constants[i].name,obj);
22569 Py_DECREF(obj);
22570 }
22571 }
22572 }
22573
22574 /* -----------------------------------------------------------------------------*/
22575 /* Fix SwigMethods to carry the callback ptrs when needed */
22576 /* -----------------------------------------------------------------------------*/
22577
22578 static void
22579 SWIG_Python_FixMethods(PyMethodDef *methods,
22580 swig_const_info *const_table,
22581 swig_type_info **types,
22582 swig_type_info **types_initial) {
22583 size_t i;
22584 for (i = 0; methods[i].ml_name; ++i) {
22585 char *c = methods[i].ml_doc;
22586 if (c && (c = strstr(c, "swig_ptr: "))) {
22587 int j;
22588 swig_const_info *ci = 0;
22589 char *name = c + 10;
22590 for (j = 0; const_table[j].type; j++) {
22591 if (strncmp(const_table[j].name, name,
22592 strlen(const_table[j].name)) == 0) {
22593 ci = &(const_table[j]);
22594 break;
22595 }
22596 }
22597 if (ci) {
22598 size_t shift = (ci->ptype) - types;
22599 swig_type_info *ty = types_initial[shift];
22600 size_t ldoc = (c - methods[i].ml_doc);
22601 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22602 char *ndoc = (char*)malloc(ldoc + lptr + 10);
22603 char *buff = ndoc;
22604 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
22605 strncpy(buff, methods[i].ml_doc, ldoc);
22606 buff += ldoc;
22607 strncpy(buff, "swig_ptr: ", 10);
22608 buff += 10;
22609 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22610 methods[i].ml_doc = ndoc;
22611 }
22612 }
22613 }
22614 }
22615
22616 /* -----------------------------------------------------------------------------*
22617 * Initialize type list
22618 * -----------------------------------------------------------------------------*/
22619
22620 #if PY_MAJOR_VERSION < 2
22621 /* PyModule_AddObject function was introduced in Python 2.0. The following function
22622 is copied out of Python/modsupport.c in python version 2.3.4 */
22623 static int
22624 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
22625 {
22626 PyObject *dict;
22627 if (!PyModule_Check(m)) {
22628 PyErr_SetString(PyExc_TypeError,
22629 "PyModule_AddObject() needs module as first arg");
22630 return -1;
22631 }
22632 if (!o) {
22633 PyErr_SetString(PyExc_TypeError,
22634 "PyModule_AddObject() needs non-NULL value");
22635 return -1;
22636 }
22637
22638 dict = PyModule_GetDict(m);
22639 if (dict == NULL) {
22640 /* Internal error -- modules must have a dict! */
22641 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
22642 PyModule_GetName(m));
22643 return -1;
22644 }
22645 if (PyDict_SetItemString(dict, name, o))
22646 return -1;
22647 Py_DECREF(o);
22648 return 0;
22649 }
22650 #endif
22651
22652 static swig_type_info **
22653 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
22654 static PyMethodDef swig_empty_runtime_method_table[] = {
22655 {
22656 NULL, NULL, 0, NULL
22657 }
22658 };/* Sentinel */
22659
22660 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
22661 swig_empty_runtime_method_table);
22662 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
22663 if (pointer && module) {
22664 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
22665 }
22666 return type_list_handle;
22667 }
22668
22669 static swig_type_info **
22670 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
22671 swig_type_info **type_pointer;
22672
22673 /* first check if module already created */
22674 type_pointer = SWIG_Python_GetTypeListHandle();
22675 if (type_pointer) {
22676 return type_pointer;
22677 } else {
22678 /* create a new module and variable */
22679 return SWIG_Python_SetTypeListHandle(type_list_handle);
22680 }
22681 }
22682
22683 #ifdef __cplusplus
22684 }
22685 #endif
22686
22687 /* -----------------------------------------------------------------------------*
22688 * Partial Init method
22689 * -----------------------------------------------------------------------------*/
22690
22691 #ifdef SWIG_LINK_RUNTIME
22692 #ifdef __cplusplus
22693 extern "C"
22694 #endif
22695 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
22696 #endif
22697
22698 #ifdef __cplusplus
22699 extern "C"
22700 #endif
22701 SWIGEXPORT(void) SWIG_init(void) {
22702 static PyObject *SWIG_globals = 0;
22703 static int typeinit = 0;
22704 PyObject *m, *d;
22705 int i;
22706 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
22707
22708 /* Fix SwigMethods to carry the callback ptrs when needed */
22709 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
22710
22711 m = Py_InitModule((char *) SWIG_name, SwigMethods);
22712 d = PyModule_GetDict(m);
22713
22714 if (!typeinit) {
22715 #ifdef SWIG_LINK_RUNTIME
22716 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
22717 #else
22718 # ifndef SWIG_STATIC_RUNTIME
22719 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
22720 # endif
22721 #endif
22722 for (i = 0; swig_types_initial[i]; i++) {
22723 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
22724 }
22725 typeinit = 1;
22726 }
22727 SWIG_InstallConstants(d,swig_const_table);
22728
22729 {
22730 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
22731 }
22732 {
22733 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
22734 }
22735 {
22736 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
22737 }
22738 {
22739 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
22740 }
22741 {
22742 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
22743 }
22744 {
22745 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
22746 }
22747 {
22748 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
22749 }
22750 {
22751 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
22752 }
22753 {
22754 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
22755 }
22756 {
22757 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
22758 }
22759 {
22760 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
22761 }
22762 {
22763 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
22764 }
22765 {
22766 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
22767 }
22768 {
22769 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
22770 }
22771 {
22772 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
22773 }
22774 {
22775 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
22776 }
22777 {
22778 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
22779 }
22780 {
22781 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
22782 }
22783 {
22784 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
22785 }
22786 {
22787 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
22788 }
22789 {
22790 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
22791 }
22792 {
22793 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
22794 }
22795 {
22796 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
22797 }
22798 {
22799 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
22800 }
22801 {
22802 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
22803 }
22804 {
22805 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
22806 }
22807 {
22808 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
22809 }
22810 {
22811 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
22812 }
22813 {
22814 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
22815 }
22816 {
22817 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
22818 }
22819 {
22820 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
22821 }
22822 {
22823 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
22824 }
22825 {
22826 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
22827 }
22828 {
22829 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
22830 }
22831 {
22832 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
22833 }
22834 {
22835 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
22836 }
22837 {
22838 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
22839 }
22840 {
22841 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
22842 }
22843 {
22844 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
22845 }
22846 {
22847 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
22848 }
22849 {
22850 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
22851 }
22852 {
22853 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
22854 }
22855 {
22856 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
22857 }
22858 {
22859 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
22860 }
22861 {
22862 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
22863 }
22864 {
22865 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
22866 }
22867 {
22868 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
22869 }
22870 {
22871 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
22872 }
22873 {
22874 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
22875 }
22876 {
22877 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
22878 }
22879 {
22880 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
22881 }
22882 {
22883 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
22884 }
22885 {
22886 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
22887 }
22888 {
22889 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
22890 }
22891 {
22892 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
22893 }
22894 {
22895 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
22896 }
22897 {
22898 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
22899 }
22900 {
22901 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
22902 }
22903 {
22904 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
22905 }
22906 {
22907 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
22908 }
22909 {
22910 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
22911 }
22912 {
22913 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
22914 }
22915 {
22916 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
22917 }
22918 {
22919 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
22920 }
22921 {
22922 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
22923 }
22924 {
22925 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
22926 }
22927 {
22928 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
22929 }
22930 {
22931 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
22932 }
22933 {
22934 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
22935 }
22936 {
22937 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
22938 }
22939 {
22940 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
22941 }
22942 {
22943 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
22944 }
22945 {
22946 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
22947 }
22948 {
22949 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
22950 }
22951 {
22952 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
22953 }
22954 {
22955 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
22956 }
22957 {
22958 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
22959 }
22960 {
22961 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
22962 }
22963 {
22964 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
22965 }
22966 {
22967 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
22968 }
22969 {
22970 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
22971 }
22972 {
22973 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
22974 }
22975 {
22976 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
22977 }
22978 {
22979 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
22980 }
22981 {
22982 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
22983 }
22984 {
22985 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
22986 }
22987 {
22988 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
22989 }
22990 {
22991 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
22992 }
22993 {
22994 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
22995 }
22996 {
22997 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
22998 }
22999 {
23000 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
23001 }
23002 {
23003 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
23004 }
23005 {
23006 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
23007 }
23008 {
23009 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
23010 }
23011 {
23012 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
23013 }
23014 {
23015 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
23016 }
23017 {
23018 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
23019 }
23020 {
23021 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
23022 }
23023 {
23024 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
23025 }
23026 {
23027 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
23028 }
23029 {
23030 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
23031 }
23032 {
23033 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
23034 }
23035 {
23036 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
23037 }
23038 {
23039 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
23040 }
23041 {
23042 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
23043 }
23044 {
23045 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
23046 }
23047 {
23048 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
23049 }
23050 {
23051 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
23052 }
23053 {
23054 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
23055 }
23056 {
23057 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
23058 }
23059 {
23060 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
23061 }
23062 {
23063 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
23064 }
23065 {
23066 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
23067 }
23068 {
23069 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
23070 }
23071 {
23072 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
23073 }
23074 {
23075 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
23076 }
23077 {
23078 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
23079 }
23080 {
23081 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
23082 }
23083 {
23084 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
23085 }
23086 {
23087 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
23088 }
23089 {
23090 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
23091 }
23092 {
23093 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
23094 }
23095 {
23096 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
23097 }
23098 {
23099 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
23100 }
23101 {
23102 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
23103 }
23104 {
23105 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
23106 }
23107 {
23108 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
23109 }
23110
23111 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
23112
23113 {
23114 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
23115 }
23116 {
23117 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
23118 }
23119 {
23120 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
23121 }
23122 {
23123 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
23124 }
23125 {
23126 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
23127 }
23128 {
23129 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
23130 }
23131 {
23132 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
23133 }
23134 {
23135 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
23136 }
23137 {
23138 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
23139 }
23140 {
23141 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
23142 }
23143 {
23144 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
23145 }
23146 {
23147 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
23148 }
23149 {
23150 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
23151 }
23152 {
23153 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
23154 }
23155 {
23156 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
23157 }
23158 {
23159 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
23160 }
23161 {
23162 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
23163 }
23164 {
23165 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
23166 }
23167 {
23168 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
23169 }
23170 {
23171 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
23172 }
23173 {
23174 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
23175 }
23176 {
23177 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
23178 }
23179 {
23180 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
23181 }
23182 {
23183 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
23184 }
23185 {
23186 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
23187 }
23188 {
23189 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
23190 }
23191 {
23192 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
23193 }
23194 {
23195 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
23196 }
23197 {
23198 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
23199 }
23200 {
23201 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
23202 }
23203 {
23204 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
23205 }
23206 {
23207 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
23208 }
23209 {
23210 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
23211 }
23212 {
23213 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
23214 }
23215 {
23216 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
23217 }
23218 {
23219 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
23220 }
23221 {
23222 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
23223 }
23224 {
23225 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
23226 }
23227 {
23228 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
23229 }
23230 {
23231 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
23232 }
23233 {
23234 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
23235 }
23236 {
23237 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
23238 }
23239 {
23240 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
23241 }
23242 {
23243 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
23244 }
23245 {
23246 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
23247 }
23248 {
23249 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
23250 }
23251 {
23252 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
23253 }
23254 {
23255 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
23256 }
23257 {
23258 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
23259 }
23260 {
23261 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
23262 }
23263 {
23264 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
23265 }
23266 {
23267 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
23268 }
23269 {
23270 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
23271 }
23272 {
23273 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
23274 }
23275 {
23276 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
23277 }
23278 {
23279 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
23280 }
23281 {
23282 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
23283 }
23284 {
23285 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
23286 }
23287 {
23288 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
23289 }
23290 {
23291 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
23292 }
23293 {
23294 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
23295 }
23296 {
23297 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
23298 }
23299 {
23300 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
23301 }
23302 {
23303 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
23304 }
23305 {
23306 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
23307 }
23308 {
23309 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
23310 }
23311 {
23312 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
23313 }
23314 {
23315 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
23316 }
23317 {
23318 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
23319 }
23320 {
23321 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
23322 }
23323 {
23324 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
23325 }
23326 {
23327 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
23328 }
23329 {
23330 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
23331 }
23332 {
23333 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
23334 }
23335 {
23336 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
23337 }
23338 {
23339 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
23340 }
23341 {
23342 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
23343 }
23344 {
23345 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
23346 }
23347 {
23348 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
23349 }
23350 {
23351 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
23352 }
23353 {
23354 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
23355 }
23356 {
23357 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
23358 }
23359 {
23360 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
23361 }
23362 {
23363 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
23364 }
23365 {
23366 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
23367 }
23368 {
23369 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
23370 }
23371 {
23372 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
23373 }
23374 {
23375 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
23376 }
23377 {
23378 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
23379 }
23380 {
23381 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
23382 }
23383 {
23384 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
23385 }
23386 {
23387 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
23388 }
23389 {
23390 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
23391 }
23392 {
23393 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
23394 }
23395 {
23396 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
23397 }
23398 {
23399 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
23400 }
23401 {
23402 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
23403 }
23404 {
23405 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
23406 }
23407 {
23408 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
23409 }
23410 {
23411 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
23412 }
23413 {
23414 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
23415 }
23416 {
23417 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
23418 }
23419 {
23420 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
23421 }
23422 {
23423 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
23424 }
23425 {
23426 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
23427 }
23428 {
23429 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
23430 }
23431 {
23432 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
23433 }
23434 {
23435 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
23436 }
23437 {
23438 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
23439 }
23440 {
23441 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
23442 }
23443 {
23444 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
23445 }
23446 {
23447 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
23448 }
23449 {
23450 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
23451 }
23452 {
23453 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
23454 }
23455 {
23456 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
23457 }
23458 {
23459 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
23460 }
23461 {
23462 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
23463 }
23464 {
23465 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
23466 }
23467 {
23468 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
23469 }
23470 {
23471 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
23472 }
23473 {
23474 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
23475 }
23476 {
23477 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
23478 }
23479 {
23480 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
23481 }
23482 {
23483 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
23484 }
23485 {
23486 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
23487 }
23488 {
23489 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
23490 }
23491 {
23492 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
23493 }
23494 {
23495 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
23496 }
23497 {
23498 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
23499 }
23500 {
23501 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
23502 }
23503 {
23504 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
23505 }
23506 {
23507 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
23508 }
23509 {
23510 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
23511 }
23512 {
23513 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
23514 }
23515 {
23516 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
23517 }
23518 {
23519 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
23520 }
23521 {
23522 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
23523 }
23524 {
23525 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
23526 }
23527 {
23528 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
23529 }
23530 {
23531 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
23532 }
23533 {
23534 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
23535 }
23536 {
23537 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
23538 }
23539 {
23540 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
23541 }
23542 {
23543 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
23544 }
23545 {
23546 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
23547 }
23548 {
23549 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
23550 }
23551 {
23552 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
23553 }
23554 {
23555 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
23556 }
23557 {
23558 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
23559 }
23560 {
23561 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
23562 }
23563 {
23564 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
23565 }
23566 {
23567 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
23568 }
23569 {
23570 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
23571 }
23572 {
23573 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
23574 }
23575 {
23576 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
23577 }
23578 {
23579 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
23580 }
23581 {
23582 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
23583 }
23584 {
23585 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
23586 }
23587 {
23588 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
23589 }
23590 {
23591 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
23592 }
23593 {
23594 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
23595 }
23596 {
23597 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
23598 }
23599 {
23600 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
23601 }
23602 {
23603 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
23604 }
23605 {
23606 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
23607 }
23608 {
23609 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
23610 }
23611 {
23612 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
23613 }
23614 {
23615 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
23616 }
23617 {
23618 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
23619 }
23620 {
23621 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
23622 }
23623 {
23624 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
23625 }
23626 {
23627 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
23628 }
23629 {
23630 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
23631 }
23632 {
23633 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
23634 }
23635 {
23636 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
23637 }
23638 {
23639 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
23640 }
23641 {
23642 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
23643 }
23644 {
23645 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
23646 }
23647 {
23648 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
23649 }
23650 {
23651 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
23652 }
23653 {
23654 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
23655 }
23656 {
23657 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
23658 }
23659 {
23660 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
23661 }
23662 {
23663 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
23664 }
23665 {
23666 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
23667 }
23668 {
23669 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
23670 }
23671 {
23672 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
23673 }
23674 {
23675 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
23676 }
23677 {
23678 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
23679 }
23680 {
23681 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
23682 }
23683 {
23684 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
23685 }
23686 {
23687 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
23688 }
23689 {
23690 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
23691 }
23692 {
23693 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
23694 }
23695 {
23696 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
23697 }
23698 {
23699 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
23700 }
23701 {
23702 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
23703 }
23704 {
23705 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
23706 }
23707 {
23708 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
23709 }
23710 {
23711 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
23712 }
23713 {
23714 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
23715 }
23716 {
23717 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
23718 }
23719 {
23720 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
23721 }
23722 {
23723 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
23724 }
23725 {
23726 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
23727 }
23728 {
23729 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
23730 }
23731 {
23732 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
23733 }
23734 {
23735 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
23736 }
23737 {
23738 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
23739 }
23740 {
23741 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
23742 }
23743 {
23744 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
23745 }
23746 {
23747 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
23748 }
23749 {
23750 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
23751 }
23752 {
23753 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
23754 }
23755 {
23756 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
23757 }
23758 {
23759 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
23760 }
23761 {
23762 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
23763 }
23764 {
23765 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
23766 }
23767 {
23768 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
23769 }
23770 {
23771 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
23772 }
23773 {
23774 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
23775 }
23776 {
23777 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
23778 }
23779 {
23780 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
23781 }
23782 {
23783 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
23784 }
23785 {
23786 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
23787 }
23788 {
23789 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
23790 }
23791 {
23792 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
23793 }
23794 {
23795 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
23796 }
23797 {
23798 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
23799 }
23800 {
23801 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
23802 }
23803 {
23804 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
23805 }
23806 {
23807 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
23808 }
23809 {
23810 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
23811 }
23812 {
23813 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
23814 }
23815 {
23816 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
23817 }
23818 {
23819 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
23820 }
23821 {
23822 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
23823 }
23824 {
23825 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
23826 }
23827 {
23828 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
23829 }
23830 {
23831 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
23832 }
23833 {
23834 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
23835 }
23836 {
23837 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
23838 }
23839 {
23840 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
23841 }
23842 {
23843 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
23844 }
23845 {
23846 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
23847 }
23848 {
23849 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
23850 }
23851 {
23852 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
23853 }
23854 {
23855 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
23856 }
23857 {
23858 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
23859 }
23860 {
23861 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
23862 }
23863 {
23864 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
23865 }
23866 {
23867 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
23868 }
23869 {
23870 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
23871 }
23872 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
23873 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
23874 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
23875 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
23876 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
23877 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
23878 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
23879 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
23880 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
23881 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
23882 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
23883 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
23884 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
23885 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
23886 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
23887 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
23888 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
23889 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
23890 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
23891 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
23892 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
23893 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
23894 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
23895 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
23896 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
23897 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
23898 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
23899 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
23900 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
23901 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
23902 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
23903 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
23904 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
23905 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
23906 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
23907 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
23908 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
23909 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
23910 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
23911 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
23912 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
23913 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
23914 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
23915 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
23916 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
23917 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
23918 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
23919
23920 // Work around a chicken/egg problem in drawlist.cpp
23921 wxPyDrawList_SetAPIPtr();
23922
23923 }
23924
wxWidgets (Impactor)