]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_gdi_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Compile fixes
[wxWidgets.git] / wxPython / src / gtk / _gdi_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxPostScriptDC swig_types[0]
1343 #define SWIGTYPE_p_wxBrush swig_types[1]
1344 #define SWIGTYPE_p_wxColour swig_types[2]
1345 #define SWIGTYPE_p_wxDC swig_types[3]
1346 #define SWIGTYPE_p_wxMirrorDC swig_types[4]
1347 #define SWIGTYPE_p_form_ops_t swig_types[5]
1348 #define SWIGTYPE_p_wxDuplexMode swig_types[6]
1349 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[7]
1350 #define SWIGTYPE_p_char swig_types[8]
1351 #define SWIGTYPE_p_wxIconLocation swig_types[9]
1352 #define SWIGTYPE_p_wxImage swig_types[10]
1353 #define SWIGTYPE_p_wxMetaFileDC swig_types[11]
1354 #define SWIGTYPE_p_wxMask swig_types[12]
1355 #define SWIGTYPE_p_wxSize swig_types[13]
1356 #define SWIGTYPE_p_wxFont swig_types[14]
1357 #define SWIGTYPE_p_wxWindow swig_types[15]
1358 #define SWIGTYPE_p_double swig_types[16]
1359 #define SWIGTYPE_p_wxMemoryDC swig_types[17]
1360 #define SWIGTYPE_p_wxFontMapper swig_types[18]
1361 #define SWIGTYPE_p_wxEffects swig_types[19]
1362 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[20]
1363 #define SWIGTYPE_p_wxPalette swig_types[21]
1364 #define SWIGTYPE_p_wxBitmap swig_types[22]
1365 #define SWIGTYPE_p_wxObject swig_types[23]
1366 #define SWIGTYPE_p_wxRegionIterator swig_types[24]
1367 #define SWIGTYPE_p_wxRect swig_types[25]
1368 #define SWIGTYPE_p_wxPaperSize swig_types[26]
1369 #define SWIGTYPE_p_wxString swig_types[27]
1370 #define SWIGTYPE_unsigned_int swig_types[28]
1371 #define SWIGTYPE_p_unsigned_int swig_types[29]
1372 #define SWIGTYPE_p_wxPrinterDC swig_types[30]
1373 #define SWIGTYPE_p_wxIconBundle swig_types[31]
1374 #define SWIGTYPE_p_wxPoint swig_types[32]
1375 #define SWIGTYPE_p_wxDash swig_types[33]
1376 #define SWIGTYPE_p_wxScreenDC swig_types[34]
1377 #define SWIGTYPE_p_wxCursor swig_types[35]
1378 #define SWIGTYPE_p_wxClientDC swig_types[36]
1379 #define SWIGTYPE_p_wxBufferedDC swig_types[37]
1380 #define SWIGTYPE_p_wxImageList swig_types[38]
1381 #define SWIGTYPE_p_unsigned_char swig_types[39]
1382 #define SWIGTYPE_p_wxGDIObject swig_types[40]
1383 #define SWIGTYPE_p_wxIcon swig_types[41]
1384 #define SWIGTYPE_p_wxLocale swig_types[42]
1385 #define SWIGTYPE_ptrdiff_t swig_types[43]
1386 #define SWIGTYPE_std__ptrdiff_t swig_types[44]
1387 #define SWIGTYPE_p_wxRegion swig_types[45]
1388 #define SWIGTYPE_p_wxConfigBase swig_types[46]
1389 #define SWIGTYPE_p_wxLanguageInfo swig_types[47]
1390 #define SWIGTYPE_p_wxWindowDC swig_types[48]
1391 #define SWIGTYPE_p_wxPrintData swig_types[49]
1392 #define SWIGTYPE_p_wxBrushList swig_types[50]
1393 #define SWIGTYPE_p_wxFontList swig_types[51]
1394 #define SWIGTYPE_p_wxPen swig_types[52]
1395 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[53]
1396 #define SWIGTYPE_p_wxPaintDC swig_types[54]
1397 #define SWIGTYPE_p_wxPenList swig_types[55]
1398 #define SWIGTYPE_p_int swig_types[56]
1399 #define SWIGTYPE_p_wxMetaFile swig_types[57]
1400 #define SWIGTYPE_p_unsigned_long swig_types[58]
1401 #define SWIGTYPE_p_wxNativeFontInfo swig_types[59]
1402 #define SWIGTYPE_p_wxEncodingConverter swig_types[60]
1403 #define SWIGTYPE_p_wxColourDatabase swig_types[61]
1404 static swig_type_info *swig_types[63];
1405
1406 /* -------- TYPES TABLE (END) -------- */
1407
1408
1409 /*-----------------------------------------------
1410 @(target):= _gdi_.so
1411 ------------------------------------------------*/
1412 #define SWIG_init init_gdi_
1413
1414 #define SWIG_name "_gdi_"
1415
1416 #include "wx/wxPython/wxPython.h"
1417 #include "wx/wxPython/pyclasses.h"
1418
1419
1420 static const wxString wxPyEmptyString(wxEmptyString);
1421
1422 #include <limits.h>
1423
1424
1425 SWIGINTERN int
1426 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1427 const char *errmsg)
1428 {
1429 if (value < min_value) {
1430 if (errmsg) {
1431 PyErr_Format(PyExc_OverflowError,
1432 "value %ld is less than '%s' minimum %ld",
1433 value, errmsg, min_value);
1434 }
1435 return 0;
1436 } else if (value > max_value) {
1437 if (errmsg) {
1438 PyErr_Format(PyExc_OverflowError,
1439 "value %ld is greater than '%s' maximum %ld",
1440 value, errmsg, max_value);
1441 }
1442 return 0;
1443 }
1444 return 1;
1445 }
1446
1447
1448 SWIGINTERN int
1449 SWIG_AsVal_long(PyObject* obj, long* val)
1450 {
1451 if (PyNumber_Check(obj)) {
1452 if (val) *val = PyInt_AsLong(obj);
1453 return 1;
1454 }
1455 else {
1456 SWIG_type_error("number", obj);
1457 }
1458 return 0;
1459 }
1460
1461
1462 #if INT_MAX != LONG_MAX
1463 SWIGINTERN int
1464 SWIG_AsVal_int(PyObject *obj, int *val)
1465 {
1466 const char* errmsg = val ? "int" : (char*)0;
1467 long v;
1468 if (SWIG_AsVal_long(obj, &v)) {
1469 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1470 if (val) *val = (int)(v);
1471 return 1;
1472 } else {
1473 return 0;
1474 }
1475 } else {
1476 PyErr_Clear();
1477 }
1478 if (val) {
1479 SWIG_type_error(errmsg, obj);
1480 }
1481 return 0;
1482 }
1483 #else
1484 SWIGINTERNSHORT int
1485 SWIG_AsVal_int(PyObject *obj, int *val)
1486 {
1487 return SWIG_AsVal_long(obj,(long*)val);
1488 }
1489 #endif
1490
1491
1492 SWIGINTERN int
1493 SWIG_AsVal_bool(PyObject *obj, bool *val)
1494 {
1495 if (obj == Py_True) {
1496 if (val) *val = true;
1497 return 1;
1498 }
1499 if (obj == Py_False) {
1500 if (val) *val = false;
1501 return 1;
1502 }
1503 int res = 0;
1504 if (SWIG_AsVal_int(obj, &res)) {
1505 if (val) *val = res ? true : false;
1506 return 1;
1507 } else {
1508 PyErr_Clear();
1509 }
1510 if (val) {
1511 SWIG_type_error("bool", obj);
1512 }
1513 return 0;
1514 }
1515
1516
1517 SWIGINTERNSHORT bool
1518 SWIG_As_bool(PyObject* obj)
1519 {
1520 bool v;
1521 if (!SWIG_AsVal_bool(obj, &v)) {
1522 /*
1523 this is needed to make valgrind/purify happier.
1524 */
1525 memset((void*)&v, 0, sizeof(bool));
1526 }
1527 return v;
1528 }
1529
1530
1531 SWIGINTERNSHORT int
1532 SWIG_Check_bool(PyObject* obj)
1533 {
1534 return SWIG_AsVal_bool(obj, (bool*)0);
1535 }
1536
1537
1538 SWIGINTERN int
1539 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1540 {
1541 long v = 0;
1542 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1543 SWIG_type_error("unsigned number", obj);
1544 }
1545 else if (val)
1546 *val = (unsigned long)v;
1547 return 1;
1548 }
1549
1550
1551 SWIGINTERNSHORT int
1552 SWIG_CheckUnsignedLongInRange(unsigned long value,
1553 unsigned long max_value,
1554 const char *errmsg)
1555 {
1556 if (value > max_value) {
1557 if (errmsg) {
1558 PyErr_Format(PyExc_OverflowError,
1559 "value %lu is greater than '%s' minimum %lu",
1560 value, errmsg, max_value);
1561 }
1562 return 0;
1563 }
1564 return 1;
1565 }
1566
1567
1568 SWIGINTERN int
1569 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1570 {
1571 const char* errmsg = val ? "unsigned char" : (char*)0;
1572 unsigned long v;
1573 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1574 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1575 if (val) *val = (unsigned char)(v);
1576 return 1;
1577 } else {
1578 return 0;
1579 }
1580 } else {
1581 PyErr_Clear();
1582 }
1583 if (val) {
1584 SWIG_type_error(errmsg, obj);
1585 }
1586 return 0;
1587 }
1588
1589
1590 SWIGINTERNSHORT unsigned char
1591 SWIG_As_unsigned_SS_char(PyObject* obj)
1592 {
1593 unsigned char v;
1594 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1595 /*
1596 this is needed to make valgrind/purify happier.
1597 */
1598 memset((void*)&v, 0, sizeof(unsigned char));
1599 }
1600 return v;
1601 }
1602
1603
1604 SWIGINTERNSHORT int
1605 SWIG_Check_unsigned_SS_char(PyObject* obj)
1606 {
1607 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1608 }
1609
1610
1611 SWIGINTERNSHORT unsigned long
1612 SWIG_As_unsigned_SS_long(PyObject* obj)
1613 {
1614 unsigned long v;
1615 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1616 /*
1617 this is needed to make valgrind/purify happier.
1618 */
1619 memset((void*)&v, 0, sizeof(unsigned long));
1620 }
1621 return v;
1622 }
1623
1624
1625 SWIGINTERNSHORT int
1626 SWIG_Check_unsigned_SS_long(PyObject* obj)
1627 {
1628 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1629 }
1630
1631
1632 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1633 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1634 /*@@*/
1635
1636
1637 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1638 #define SWIG_From_long PyInt_FromLong
1639 /*@@*/
1640
1641 static PyObject *wxColour_Get(wxColour *self){
1642 PyObject* rv = PyTuple_New(3);
1643 int red = -1;
1644 int green = -1;
1645 int blue = -1;
1646 if (self->Ok()) {
1647 red = self->Red();
1648 green = self->Green();
1649 blue = self->Blue();
1650 }
1651 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1652 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1653 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1654 return rv;
1655 }
1656 static unsigned long wxColour_GetRGB(wxColour *self){
1657 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1658 }
1659
1660 SWIGINTERNSHORT PyObject*
1661 SWIG_From_unsigned_SS_long(unsigned long value)
1662 {
1663 return (value > LONG_MAX) ?
1664 PyLong_FromUnsignedLong(value)
1665 : PyInt_FromLong((long)(value));
1666 }
1667
1668
1669 SWIGINTERNSHORT int
1670 SWIG_As_int(PyObject* obj)
1671 {
1672 int v;
1673 if (!SWIG_AsVal_int(obj, &v)) {
1674 /*
1675 this is needed to make valgrind/purify happier.
1676 */
1677 memset((void*)&v, 0, sizeof(int));
1678 }
1679 return v;
1680 }
1681
1682
1683 SWIGINTERNSHORT int
1684 SWIG_Check_int(PyObject* obj)
1685 {
1686 return SWIG_AsVal_int(obj, (int*)0);
1687 }
1688
1689
1690 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1691 #define SWIG_From_int PyInt_FromLong
1692 /*@@*/
1693
1694
1695 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1696 PyObject* o2;
1697 PyObject* o3;
1698
1699 if (!target) {
1700 target = o;
1701 } else if (target == Py_None) {
1702 Py_DECREF(Py_None);
1703 target = o;
1704 } else {
1705 if (!PyTuple_Check(target)) {
1706 o2 = target;
1707 target = PyTuple_New(1);
1708 PyTuple_SetItem(target, 0, o2);
1709 }
1710 o3 = PyTuple_New(1);
1711 PyTuple_SetItem(o3, 0, o);
1712
1713 o2 = target;
1714 target = PySequence_Concat(o2, o3);
1715 Py_DECREF(o2);
1716 Py_DECREF(o3);
1717 }
1718 return target;
1719 }
1720
1721
1722 static PyObject *wxPen_GetDashes(wxPen *self){
1723 wxDash* dashes;
1724 int count = self->GetDashes(&dashes);
1725 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1726 PyObject* retval = PyList_New(0);
1727 for (int x=0; x<count; x++) {
1728 PyObject* pyint = PyInt_FromLong(dashes[x]);
1729 PyList_Append(retval, pyint);
1730 Py_DECREF(pyint);
1731 }
1732 wxPyEndBlockThreads(blocked);
1733 return retval;
1734 }
1735 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1736 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1737 int size = PyList_Size(pyDashes);
1738 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1739
1740 // black magic warning! The array of wxDashes needs to exist as
1741 // long as the pen does because wxPen does not copy the array. So
1742 // stick a copy in a Python string object and attach it to _self,
1743 // and then call SetDashes with a pointer to that array. Then
1744 // when the Python pen object is destroyed the array will be
1745 // cleaned up too.
1746 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1747 PyObject_SetAttrString(_self, "_dashes", strDashes);
1748
1749 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1750 delete [] dashes;
1751 Py_DECREF(strDashes);
1752 wxPyEndBlockThreads(blocked);
1753 }
1754 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1755 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1756
1757 #include <wx/image.h>
1758
1759 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1760 char** cArray = NULL;
1761 int count;
1762
1763 if (!PyList_Check(listOfStrings)) {
1764 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1765 return NULL;
1766 }
1767 count = PyList_Size(listOfStrings);
1768 cArray = new char*[count];
1769
1770 for(int x=0; x<count; x++) {
1771 // TODO: Need some validation and error checking here
1772 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1773 }
1774 return cArray;
1775 }
1776
1777
1778 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1779 char** cArray = NULL;
1780 wxBitmap* bmp;
1781
1782 cArray = ConvertListOfStrings(listOfStrings);
1783 if (! cArray)
1784 return NULL;
1785 bmp = new wxBitmap(cArray);
1786 delete [] cArray;
1787 return bmp;
1788 }
1789 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1790 char* buf;
1791 int length;
1792 PyString_AsStringAndSize(bits, &buf, &length);
1793 return new wxBitmap(buf, width, height, depth);
1794 }
1795 static wxSize wxBitmap_GetSize(wxBitmap *self){
1796 wxSize size(self->GetWidth(), self->GetHeight());
1797 return size;
1798 }
1799 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1800 wxMask *mask = new wxMask(*self, colour);
1801 self->SetMask(mask);
1802 }
1803 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1804 self->SetWidth(size.x);
1805 self->SetHeight(size.y);
1806 }
1807 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1808 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1809 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1810 if ( !colour.Ok() )
1811 return new wxMask(bitmap, *wxBLACK);
1812 else
1813 return new wxMask(bitmap, colour);
1814 }
1815
1816 #include <wx/iconbndl.h>
1817
1818 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1819 wxIcon* icon = new wxIcon();
1820 icon->CopyFromBitmap(bmp);
1821 return icon;
1822 }
1823 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1824 char** cArray = NULL;
1825 wxIcon* icon;
1826
1827 cArray = ConvertListOfStrings(listOfStrings);
1828 if (! cArray)
1829 return NULL;
1830 icon = new wxIcon(cArray);
1831 delete [] cArray;
1832 return icon;
1833 }
1834 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1835
1836
1837
1838 return new wxIconLocation(*filename);
1839
1840 }
1841 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1842
1843
1844
1845 // do nothing
1846
1847 }
1848 static int wxIconLocation_GetIndex(wxIconLocation *self){
1849
1850
1851
1852 return -1;
1853
1854 }
1855
1856 SWIGINTERNSHORT long
1857 SWIG_As_long(PyObject* obj)
1858 {
1859 long v;
1860 if (!SWIG_AsVal_long(obj, &v)) {
1861 /*
1862 this is needed to make valgrind/purify happier.
1863 */
1864 memset((void*)&v, 0, sizeof(long));
1865 }
1866 return v;
1867 }
1868
1869
1870 SWIGINTERNSHORT int
1871 SWIG_Check_long(PyObject* obj)
1872 {
1873 return SWIG_AsVal_long(obj, (long*)0);
1874 }
1875
1876 static wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1877 #ifdef __WXGTK__
1878 wxImage img(cursorName, type);
1879 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
1880 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
1881 return new wxCursor(img);
1882 #else
1883 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
1884 #endif
1885 }
1886
1887
1888 static void wxRegionIterator_Next(wxRegionIterator *self){
1889 (*self) ++;
1890 }
1891 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1892 return self->operator bool();
1893 }
1894
1895 #include <wx/fontutil.h>
1896 #include <wx/fontmap.h>
1897 #include <wx/fontenum.h>
1898
1899 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1900 return self->ToString();
1901 }
1902
1903 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
1904 static wxNativeEncodingInfo info;
1905 if ( wxGetNativeFontEncoding(encoding, &info) )
1906 return &info;
1907 else
1908 return NULL;
1909 }
1910
1911 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1912 wxFontEncoding alt_enc;
1913 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1914 return PyInt_FromLong(alt_enc);
1915 else {
1916 Py_INCREF(Py_None);
1917 return Py_None;
1918 }
1919 }
1920 static wxFont *new_wxFont(wxString const &info){
1921 wxNativeFontInfo nfi;
1922 nfi.FromString(info);
1923 return new wxFont(nfi);
1924 }
1925 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1926 return wxFont::New(pointSize, family, flags, face, encoding);
1927 }
1928 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1929 return wxFontBase::New(pixelSize, family,
1930 style, weight, underlined,
1931 face, encoding);
1932 }
1933 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1934 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1935
1936 class wxPyFontEnumerator : public wxFontEnumerator {
1937 public:
1938 wxPyFontEnumerator() {}
1939 ~wxPyFontEnumerator() {}
1940
1941 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1942 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1943
1944 PYPRIVATE;
1945 };
1946
1947 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
1948 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
1949
1950
1951 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
1952 wxArrayString* arr = self->GetEncodings();
1953 if (arr)
1954 return wxArrayString2PyList_helper(*arr);
1955 else
1956 return PyList_New(0);
1957 }
1958 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
1959 wxArrayString* arr = self->GetFacenames();
1960 if (arr)
1961 return wxArrayString2PyList_helper(*arr);
1962 else
1963 return PyList_New(0);
1964 }
1965
1966 #include <locale.h>
1967
1968 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1969 wxLocale* loc;
1970 if (language == -1)
1971 loc = new wxLocale();
1972 else
1973 loc = new wxLocale(language, flags);
1974 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1975 // for the floating point conversions and such to work right.
1976 #if PY_VERSION_HEX < 0x02040000
1977 setlocale(LC_NUMERIC, "C");
1978 #endif
1979 return loc;
1980 }
1981 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
1982 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
1983 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1984 // for the floating point conversions and such to work right.
1985 #if PY_VERSION_HEX < 0x02040000
1986 setlocale(LC_NUMERIC, "C");
1987 #endif
1988 return rc;
1989 }
1990 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1991 bool rc = self->Init(language, flags);
1992 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1993 // for the floating point conversions and such to work right.
1994 #if PY_VERSION_HEX < 0x02040000
1995 setlocale(LC_NUMERIC, "C");
1996 #endif
1997 return rc;
1998 }
1999
2000 #include "wx/wxPython/pydrawxxx.h"
2001
2002 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2003 wxColour col;
2004 self->GetPixel(x, y, &col);
2005 return col;
2006 }
2007 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2008 wxColour col;
2009 self->GetPixel(pt, &col);
2010 return col;
2011 }
2012
2013 SWIGINTERN int
2014 SWIG_AsVal_double(PyObject *obj, double* val)
2015 {
2016 if (PyNumber_Check(obj)) {
2017 if (val) *val = PyFloat_AsDouble(obj);
2018 return 1;
2019 }
2020 else {
2021 SWIG_type_error("number", obj);
2022 }
2023 return 0;
2024 }
2025
2026
2027 SWIGINTERNSHORT double
2028 SWIG_As_double(PyObject* obj)
2029 {
2030 double v;
2031 if (!SWIG_AsVal_double(obj, &v)) {
2032 /*
2033 this is needed to make valgrind/purify happier.
2034 */
2035 memset((void*)&v, 0, sizeof(double));
2036 }
2037 return v;
2038 }
2039
2040
2041 SWIGINTERNSHORT int
2042 SWIG_Check_double(PyObject* obj)
2043 {
2044 return SWIG_AsVal_double(obj, (double*)0);
2045 }
2046
2047 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2048 wxRect rv;
2049 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2050 return rv;
2051 }
2052
2053 static wxRect wxDC_GetClippingRect(wxDC *self){
2054 wxRect rect;
2055 self->GetClippingBox(rect);
2056 return rect;
2057 }
2058 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2059 wxArrayInt widths;
2060 self->GetPartialTextExtents(text, widths);
2061 return widths;
2062 }
2063
2064 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2065 #define SWIG_From_double PyFloat_FromDouble
2066 /*@@*/
2067
2068
2069 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2070 self->SetLogicalOrigin(point.x, point.y);
2071 }
2072 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2073 self->SetDeviceOrigin(point.x, point.y);
2074 }
2075 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2076 self->CalcBoundingBox(point.x, point.y);
2077 }
2078 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2079 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2080 }
2081 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2082 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2083 }
2084 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2085 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2086 }
2087 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2088 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2089 }
2090 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2091 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2092 }
2093 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2094 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2095 }
2096
2097 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2098 *x1 = dc->MinX();
2099 *y1 = dc->MinY();
2100 *x2 = dc->MaxX();
2101 *y2 = dc->MaxY();
2102 }
2103
2104
2105 #include <wx/dcbuffer.h>
2106
2107
2108 #include <wx/dcps.h>
2109
2110
2111 class wxMetaFile : public wxObject {
2112 public:
2113 wxMetaFile(const wxString&)
2114 { wxPyRaiseNotImplemented(); }
2115 };
2116
2117 class wxMetaFileDC : public wxClientDC {
2118 public:
2119 wxMetaFileDC(const wxString&, int, int, const wxString&)
2120 { wxPyRaiseNotImplemented(); }
2121 };
2122
2123
2124
2125 class wxPrinterDC : public wxClientDC {
2126 public:
2127 wxPrinterDC(const wxPrintData&)
2128 { wxPyRaiseNotImplemented(); }
2129
2130 };
2131
2132
2133
2134 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2135 self->AddColour(name, wxColour(red, green, blue));
2136 }
2137
2138 #include <wx/effects.h>
2139
2140 #ifdef __cplusplus
2141 extern "C" {
2142 #endif
2143 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2144 PyObject *resultobj;
2145 wxGDIObject *result;
2146 char *kwnames[] = {
2147 NULL
2148 };
2149
2150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2151 {
2152 if (!wxPyCheckForApp()) SWIG_fail;
2153 PyThreadState* __tstate = wxPyBeginAllowThreads();
2154 result = (wxGDIObject *)new wxGDIObject();
2155
2156 wxPyEndAllowThreads(__tstate);
2157 if (PyErr_Occurred()) SWIG_fail;
2158 }
2159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2160 return resultobj;
2161 fail:
2162 return NULL;
2163 }
2164
2165
2166 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2167 PyObject *resultobj;
2168 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2169 PyObject * obj0 = 0 ;
2170 char *kwnames[] = {
2171 (char *) "self", NULL
2172 };
2173
2174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2176 if (SWIG_arg_fail(1)) SWIG_fail;
2177 {
2178 PyThreadState* __tstate = wxPyBeginAllowThreads();
2179 delete arg1;
2180
2181 wxPyEndAllowThreads(__tstate);
2182 if (PyErr_Occurred()) SWIG_fail;
2183 }
2184 Py_INCREF(Py_None); resultobj = Py_None;
2185 return resultobj;
2186 fail:
2187 return NULL;
2188 }
2189
2190
2191 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2192 PyObject *resultobj;
2193 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2194 bool result;
2195 PyObject * obj0 = 0 ;
2196 char *kwnames[] = {
2197 (char *) "self", NULL
2198 };
2199
2200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2202 if (SWIG_arg_fail(1)) SWIG_fail;
2203 {
2204 PyThreadState* __tstate = wxPyBeginAllowThreads();
2205 result = (bool)(arg1)->GetVisible();
2206
2207 wxPyEndAllowThreads(__tstate);
2208 if (PyErr_Occurred()) SWIG_fail;
2209 }
2210 {
2211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2212 }
2213 return resultobj;
2214 fail:
2215 return NULL;
2216 }
2217
2218
2219 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2220 PyObject *resultobj;
2221 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2222 bool arg2 ;
2223 PyObject * obj0 = 0 ;
2224 PyObject * obj1 = 0 ;
2225 char *kwnames[] = {
2226 (char *) "self",(char *) "visible", NULL
2227 };
2228
2229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2231 if (SWIG_arg_fail(1)) SWIG_fail;
2232 {
2233 arg2 = (bool)(SWIG_As_bool(obj1));
2234 if (SWIG_arg_fail(2)) SWIG_fail;
2235 }
2236 {
2237 PyThreadState* __tstate = wxPyBeginAllowThreads();
2238 (arg1)->SetVisible(arg2);
2239
2240 wxPyEndAllowThreads(__tstate);
2241 if (PyErr_Occurred()) SWIG_fail;
2242 }
2243 Py_INCREF(Py_None); resultobj = Py_None;
2244 return resultobj;
2245 fail:
2246 return NULL;
2247 }
2248
2249
2250 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2251 PyObject *resultobj;
2252 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2253 bool result;
2254 PyObject * obj0 = 0 ;
2255 char *kwnames[] = {
2256 (char *) "self", NULL
2257 };
2258
2259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2261 if (SWIG_arg_fail(1)) SWIG_fail;
2262 {
2263 PyThreadState* __tstate = wxPyBeginAllowThreads();
2264 result = (bool)(arg1)->IsNull();
2265
2266 wxPyEndAllowThreads(__tstate);
2267 if (PyErr_Occurred()) SWIG_fail;
2268 }
2269 {
2270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2271 }
2272 return resultobj;
2273 fail:
2274 return NULL;
2275 }
2276
2277
2278 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2279 PyObject *obj;
2280 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2281 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2282 Py_INCREF(obj);
2283 return Py_BuildValue((char *)"");
2284 }
2285 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2286 PyObject *resultobj;
2287 byte arg1 = (byte) 0 ;
2288 byte arg2 = (byte) 0 ;
2289 byte arg3 = (byte) 0 ;
2290 wxColour *result;
2291 PyObject * obj0 = 0 ;
2292 PyObject * obj1 = 0 ;
2293 PyObject * obj2 = 0 ;
2294 char *kwnames[] = {
2295 (char *) "red",(char *) "green",(char *) "blue", NULL
2296 };
2297
2298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2299 if (obj0) {
2300 {
2301 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2302 if (SWIG_arg_fail(1)) SWIG_fail;
2303 }
2304 }
2305 if (obj1) {
2306 {
2307 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2308 if (SWIG_arg_fail(2)) SWIG_fail;
2309 }
2310 }
2311 if (obj2) {
2312 {
2313 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2314 if (SWIG_arg_fail(3)) SWIG_fail;
2315 }
2316 }
2317 {
2318 PyThreadState* __tstate = wxPyBeginAllowThreads();
2319 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2320
2321 wxPyEndAllowThreads(__tstate);
2322 if (PyErr_Occurred()) SWIG_fail;
2323 }
2324 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2325 return resultobj;
2326 fail:
2327 return NULL;
2328 }
2329
2330
2331 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2332 PyObject *resultobj;
2333 wxString *arg1 = 0 ;
2334 wxColour *result;
2335 bool temp1 = false ;
2336 PyObject * obj0 = 0 ;
2337 char *kwnames[] = {
2338 (char *) "colorName", NULL
2339 };
2340
2341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2342 {
2343 arg1 = wxString_in_helper(obj0);
2344 if (arg1 == NULL) SWIG_fail;
2345 temp1 = true;
2346 }
2347 {
2348 if (!wxPyCheckForApp()) SWIG_fail;
2349 PyThreadState* __tstate = wxPyBeginAllowThreads();
2350 result = (wxColour *)new wxColour((wxString const &)*arg1);
2351
2352 wxPyEndAllowThreads(__tstate);
2353 if (PyErr_Occurred()) SWIG_fail;
2354 }
2355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2356 {
2357 if (temp1)
2358 delete arg1;
2359 }
2360 return resultobj;
2361 fail:
2362 {
2363 if (temp1)
2364 delete arg1;
2365 }
2366 return NULL;
2367 }
2368
2369
2370 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2371 PyObject *resultobj;
2372 unsigned long arg1 ;
2373 wxColour *result;
2374 PyObject * obj0 = 0 ;
2375 char *kwnames[] = {
2376 (char *) "colRGB", NULL
2377 };
2378
2379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2380 {
2381 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2382 if (SWIG_arg_fail(1)) SWIG_fail;
2383 }
2384 {
2385 PyThreadState* __tstate = wxPyBeginAllowThreads();
2386 result = (wxColour *)new wxColour(arg1);
2387
2388 wxPyEndAllowThreads(__tstate);
2389 if (PyErr_Occurred()) SWIG_fail;
2390 }
2391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2392 return resultobj;
2393 fail:
2394 return NULL;
2395 }
2396
2397
2398 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2399 PyObject *resultobj;
2400 wxColour *arg1 = (wxColour *) 0 ;
2401 PyObject * obj0 = 0 ;
2402 char *kwnames[] = {
2403 (char *) "self", NULL
2404 };
2405
2406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2408 if (SWIG_arg_fail(1)) SWIG_fail;
2409 {
2410 PyThreadState* __tstate = wxPyBeginAllowThreads();
2411 delete arg1;
2412
2413 wxPyEndAllowThreads(__tstate);
2414 if (PyErr_Occurred()) SWIG_fail;
2415 }
2416 Py_INCREF(Py_None); resultobj = Py_None;
2417 return resultobj;
2418 fail:
2419 return NULL;
2420 }
2421
2422
2423 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2424 PyObject *resultobj;
2425 wxColour *arg1 = (wxColour *) 0 ;
2426 byte result;
2427 PyObject * obj0 = 0 ;
2428 char *kwnames[] = {
2429 (char *) "self", NULL
2430 };
2431
2432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2434 if (SWIG_arg_fail(1)) SWIG_fail;
2435 {
2436 PyThreadState* __tstate = wxPyBeginAllowThreads();
2437 result = (byte)(arg1)->Red();
2438
2439 wxPyEndAllowThreads(__tstate);
2440 if (PyErr_Occurred()) SWIG_fail;
2441 }
2442 {
2443 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2444 }
2445 return resultobj;
2446 fail:
2447 return NULL;
2448 }
2449
2450
2451 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2452 PyObject *resultobj;
2453 wxColour *arg1 = (wxColour *) 0 ;
2454 byte result;
2455 PyObject * obj0 = 0 ;
2456 char *kwnames[] = {
2457 (char *) "self", NULL
2458 };
2459
2460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2462 if (SWIG_arg_fail(1)) SWIG_fail;
2463 {
2464 PyThreadState* __tstate = wxPyBeginAllowThreads();
2465 result = (byte)(arg1)->Green();
2466
2467 wxPyEndAllowThreads(__tstate);
2468 if (PyErr_Occurred()) SWIG_fail;
2469 }
2470 {
2471 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2472 }
2473 return resultobj;
2474 fail:
2475 return NULL;
2476 }
2477
2478
2479 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2480 PyObject *resultobj;
2481 wxColour *arg1 = (wxColour *) 0 ;
2482 byte result;
2483 PyObject * obj0 = 0 ;
2484 char *kwnames[] = {
2485 (char *) "self", NULL
2486 };
2487
2488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2490 if (SWIG_arg_fail(1)) SWIG_fail;
2491 {
2492 PyThreadState* __tstate = wxPyBeginAllowThreads();
2493 result = (byte)(arg1)->Blue();
2494
2495 wxPyEndAllowThreads(__tstate);
2496 if (PyErr_Occurred()) SWIG_fail;
2497 }
2498 {
2499 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2500 }
2501 return resultobj;
2502 fail:
2503 return NULL;
2504 }
2505
2506
2507 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2508 PyObject *resultobj;
2509 wxColour *arg1 = (wxColour *) 0 ;
2510 bool result;
2511 PyObject * obj0 = 0 ;
2512 char *kwnames[] = {
2513 (char *) "self", NULL
2514 };
2515
2516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2518 if (SWIG_arg_fail(1)) SWIG_fail;
2519 {
2520 PyThreadState* __tstate = wxPyBeginAllowThreads();
2521 result = (bool)(arg1)->Ok();
2522
2523 wxPyEndAllowThreads(__tstate);
2524 if (PyErr_Occurred()) SWIG_fail;
2525 }
2526 {
2527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2528 }
2529 return resultobj;
2530 fail:
2531 return NULL;
2532 }
2533
2534
2535 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2536 PyObject *resultobj;
2537 wxColour *arg1 = (wxColour *) 0 ;
2538 byte arg2 ;
2539 byte arg3 ;
2540 byte arg4 ;
2541 PyObject * obj0 = 0 ;
2542 PyObject * obj1 = 0 ;
2543 PyObject * obj2 = 0 ;
2544 PyObject * obj3 = 0 ;
2545 char *kwnames[] = {
2546 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2547 };
2548
2549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2551 if (SWIG_arg_fail(1)) SWIG_fail;
2552 {
2553 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2554 if (SWIG_arg_fail(2)) SWIG_fail;
2555 }
2556 {
2557 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2558 if (SWIG_arg_fail(3)) SWIG_fail;
2559 }
2560 {
2561 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2562 if (SWIG_arg_fail(4)) SWIG_fail;
2563 }
2564 {
2565 PyThreadState* __tstate = wxPyBeginAllowThreads();
2566 (arg1)->Set(arg2,arg3,arg4);
2567
2568 wxPyEndAllowThreads(__tstate);
2569 if (PyErr_Occurred()) SWIG_fail;
2570 }
2571 Py_INCREF(Py_None); resultobj = Py_None;
2572 return resultobj;
2573 fail:
2574 return NULL;
2575 }
2576
2577
2578 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2579 PyObject *resultobj;
2580 wxColour *arg1 = (wxColour *) 0 ;
2581 unsigned long arg2 ;
2582 PyObject * obj0 = 0 ;
2583 PyObject * obj1 = 0 ;
2584 char *kwnames[] = {
2585 (char *) "self",(char *) "colRGB", NULL
2586 };
2587
2588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2590 if (SWIG_arg_fail(1)) SWIG_fail;
2591 {
2592 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2593 if (SWIG_arg_fail(2)) SWIG_fail;
2594 }
2595 {
2596 PyThreadState* __tstate = wxPyBeginAllowThreads();
2597 (arg1)->Set(arg2);
2598
2599 wxPyEndAllowThreads(__tstate);
2600 if (PyErr_Occurred()) SWIG_fail;
2601 }
2602 Py_INCREF(Py_None); resultobj = Py_None;
2603 return resultobj;
2604 fail:
2605 return NULL;
2606 }
2607
2608
2609 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2610 PyObject *resultobj;
2611 wxColour *arg1 = (wxColour *) 0 ;
2612 wxString *arg2 = 0 ;
2613 bool temp2 = false ;
2614 PyObject * obj0 = 0 ;
2615 PyObject * obj1 = 0 ;
2616 char *kwnames[] = {
2617 (char *) "self",(char *) "colourName", NULL
2618 };
2619
2620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2622 if (SWIG_arg_fail(1)) SWIG_fail;
2623 {
2624 arg2 = wxString_in_helper(obj1);
2625 if (arg2 == NULL) SWIG_fail;
2626 temp2 = true;
2627 }
2628 {
2629 PyThreadState* __tstate = wxPyBeginAllowThreads();
2630 (arg1)->InitFromName((wxString const &)*arg2);
2631
2632 wxPyEndAllowThreads(__tstate);
2633 if (PyErr_Occurred()) SWIG_fail;
2634 }
2635 Py_INCREF(Py_None); resultobj = Py_None;
2636 {
2637 if (temp2)
2638 delete arg2;
2639 }
2640 return resultobj;
2641 fail:
2642 {
2643 if (temp2)
2644 delete arg2;
2645 }
2646 return NULL;
2647 }
2648
2649
2650 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2651 PyObject *resultobj;
2652 wxColour *arg1 = (wxColour *) 0 ;
2653 long result;
2654 PyObject * obj0 = 0 ;
2655 char *kwnames[] = {
2656 (char *) "self", NULL
2657 };
2658
2659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2661 if (SWIG_arg_fail(1)) SWIG_fail;
2662 {
2663 PyThreadState* __tstate = wxPyBeginAllowThreads();
2664 result = (long)((wxColour const *)arg1)->GetPixel();
2665
2666 wxPyEndAllowThreads(__tstate);
2667 if (PyErr_Occurred()) SWIG_fail;
2668 }
2669 {
2670 resultobj = SWIG_From_long((long)(result));
2671 }
2672 return resultobj;
2673 fail:
2674 return NULL;
2675 }
2676
2677
2678 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2679 PyObject *resultobj;
2680 wxColour *arg1 = (wxColour *) 0 ;
2681 wxColour *arg2 = 0 ;
2682 bool result;
2683 wxColour temp2 ;
2684 PyObject * obj0 = 0 ;
2685 PyObject * obj1 = 0 ;
2686 char *kwnames[] = {
2687 (char *) "self",(char *) "colour", NULL
2688 };
2689
2690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2692 if (SWIG_arg_fail(1)) SWIG_fail;
2693 {
2694 arg2 = &temp2;
2695 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2696 }
2697 {
2698 PyThreadState* __tstate = wxPyBeginAllowThreads();
2699 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2700
2701 wxPyEndAllowThreads(__tstate);
2702 if (PyErr_Occurred()) SWIG_fail;
2703 }
2704 {
2705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2706 }
2707 return resultobj;
2708 fail:
2709 return NULL;
2710 }
2711
2712
2713 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2714 PyObject *resultobj;
2715 wxColour *arg1 = (wxColour *) 0 ;
2716 wxColour *arg2 = 0 ;
2717 bool result;
2718 wxColour temp2 ;
2719 PyObject * obj0 = 0 ;
2720 PyObject * obj1 = 0 ;
2721 char *kwnames[] = {
2722 (char *) "self",(char *) "colour", NULL
2723 };
2724
2725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2727 if (SWIG_arg_fail(1)) SWIG_fail;
2728 {
2729 arg2 = &temp2;
2730 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2731 }
2732 {
2733 PyThreadState* __tstate = wxPyBeginAllowThreads();
2734 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2735
2736 wxPyEndAllowThreads(__tstate);
2737 if (PyErr_Occurred()) SWIG_fail;
2738 }
2739 {
2740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2741 }
2742 return resultobj;
2743 fail:
2744 return NULL;
2745 }
2746
2747
2748 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2749 PyObject *resultobj;
2750 wxColour *arg1 = (wxColour *) 0 ;
2751 PyObject *result;
2752 PyObject * obj0 = 0 ;
2753 char *kwnames[] = {
2754 (char *) "self", NULL
2755 };
2756
2757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2759 if (SWIG_arg_fail(1)) SWIG_fail;
2760 {
2761 PyThreadState* __tstate = wxPyBeginAllowThreads();
2762 result = (PyObject *)wxColour_Get(arg1);
2763
2764 wxPyEndAllowThreads(__tstate);
2765 if (PyErr_Occurred()) SWIG_fail;
2766 }
2767 resultobj = result;
2768 return resultobj;
2769 fail:
2770 return NULL;
2771 }
2772
2773
2774 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2775 PyObject *resultobj;
2776 wxColour *arg1 = (wxColour *) 0 ;
2777 unsigned long result;
2778 PyObject * obj0 = 0 ;
2779 char *kwnames[] = {
2780 (char *) "self", NULL
2781 };
2782
2783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2785 if (SWIG_arg_fail(1)) SWIG_fail;
2786 {
2787 PyThreadState* __tstate = wxPyBeginAllowThreads();
2788 result = (unsigned long)wxColour_GetRGB(arg1);
2789
2790 wxPyEndAllowThreads(__tstate);
2791 if (PyErr_Occurred()) SWIG_fail;
2792 }
2793 {
2794 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2795 }
2796 return resultobj;
2797 fail:
2798 return NULL;
2799 }
2800
2801
2802 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2803 PyObject *obj;
2804 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2805 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2806 Py_INCREF(obj);
2807 return Py_BuildValue((char *)"");
2808 }
2809 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2810 PyObject *resultobj;
2811 int arg1 ;
2812 unsigned char *arg2 = (unsigned char *) 0 ;
2813 unsigned char *arg3 = (unsigned char *) 0 ;
2814 unsigned char *arg4 = (unsigned char *) 0 ;
2815 wxPalette *result;
2816 PyObject * obj0 = 0 ;
2817 PyObject * obj1 = 0 ;
2818 PyObject * obj2 = 0 ;
2819 PyObject * obj3 = 0 ;
2820 char *kwnames[] = {
2821 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2822 };
2823
2824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2825 {
2826 arg1 = (int)(SWIG_As_int(obj0));
2827 if (SWIG_arg_fail(1)) SWIG_fail;
2828 }
2829 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2830 if (SWIG_arg_fail(2)) SWIG_fail;
2831 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2832 if (SWIG_arg_fail(3)) SWIG_fail;
2833 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2834 if (SWIG_arg_fail(4)) SWIG_fail;
2835 {
2836 if (!wxPyCheckForApp()) SWIG_fail;
2837 PyThreadState* __tstate = wxPyBeginAllowThreads();
2838 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2839
2840 wxPyEndAllowThreads(__tstate);
2841 if (PyErr_Occurred()) SWIG_fail;
2842 }
2843 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2844 return resultobj;
2845 fail:
2846 return NULL;
2847 }
2848
2849
2850 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2851 PyObject *resultobj;
2852 wxPalette *arg1 = (wxPalette *) 0 ;
2853 PyObject * obj0 = 0 ;
2854 char *kwnames[] = {
2855 (char *) "self", NULL
2856 };
2857
2858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2860 if (SWIG_arg_fail(1)) SWIG_fail;
2861 {
2862 PyThreadState* __tstate = wxPyBeginAllowThreads();
2863 delete arg1;
2864
2865 wxPyEndAllowThreads(__tstate);
2866 if (PyErr_Occurred()) SWIG_fail;
2867 }
2868 Py_INCREF(Py_None); resultobj = Py_None;
2869 return resultobj;
2870 fail:
2871 return NULL;
2872 }
2873
2874
2875 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2876 PyObject *resultobj;
2877 wxPalette *arg1 = (wxPalette *) 0 ;
2878 byte arg2 ;
2879 byte arg3 ;
2880 byte arg4 ;
2881 int result;
2882 PyObject * obj0 = 0 ;
2883 PyObject * obj1 = 0 ;
2884 PyObject * obj2 = 0 ;
2885 PyObject * obj3 = 0 ;
2886 char *kwnames[] = {
2887 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2888 };
2889
2890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2892 if (SWIG_arg_fail(1)) SWIG_fail;
2893 {
2894 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2895 if (SWIG_arg_fail(2)) SWIG_fail;
2896 }
2897 {
2898 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2899 if (SWIG_arg_fail(3)) SWIG_fail;
2900 }
2901 {
2902 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2903 if (SWIG_arg_fail(4)) SWIG_fail;
2904 }
2905 {
2906 PyThreadState* __tstate = wxPyBeginAllowThreads();
2907 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2908
2909 wxPyEndAllowThreads(__tstate);
2910 if (PyErr_Occurred()) SWIG_fail;
2911 }
2912 {
2913 resultobj = SWIG_From_int((int)(result));
2914 }
2915 return resultobj;
2916 fail:
2917 return NULL;
2918 }
2919
2920
2921 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2922 PyObject *resultobj;
2923 wxPalette *arg1 = (wxPalette *) 0 ;
2924 int arg2 ;
2925 byte *arg3 = (byte *) 0 ;
2926 byte *arg4 = (byte *) 0 ;
2927 byte *arg5 = (byte *) 0 ;
2928 bool result;
2929 byte temp3 ;
2930 int res3 = 0 ;
2931 byte temp4 ;
2932 int res4 = 0 ;
2933 byte temp5 ;
2934 int res5 = 0 ;
2935 PyObject * obj0 = 0 ;
2936 PyObject * obj1 = 0 ;
2937 char *kwnames[] = {
2938 (char *) "self",(char *) "pixel", NULL
2939 };
2940
2941 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2942 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2943 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2946 if (SWIG_arg_fail(1)) SWIG_fail;
2947 {
2948 arg2 = (int)(SWIG_As_int(obj1));
2949 if (SWIG_arg_fail(2)) SWIG_fail;
2950 }
2951 {
2952 PyThreadState* __tstate = wxPyBeginAllowThreads();
2953 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2954
2955 wxPyEndAllowThreads(__tstate);
2956 if (PyErr_Occurred()) SWIG_fail;
2957 }
2958 {
2959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2960 }
2961 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2962 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2963 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2964 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2965 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2966 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2967 return resultobj;
2968 fail:
2969 return NULL;
2970 }
2971
2972
2973 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
2974 PyObject *resultobj;
2975 wxPalette *arg1 = (wxPalette *) 0 ;
2976 int result;
2977 PyObject * obj0 = 0 ;
2978 char *kwnames[] = {
2979 (char *) "self", NULL
2980 };
2981
2982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
2983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2984 if (SWIG_arg_fail(1)) SWIG_fail;
2985 {
2986 PyThreadState* __tstate = wxPyBeginAllowThreads();
2987 result = (int)((wxPalette const *)arg1)->GetColoursCount();
2988
2989 wxPyEndAllowThreads(__tstate);
2990 if (PyErr_Occurred()) SWIG_fail;
2991 }
2992 {
2993 resultobj = SWIG_From_int((int)(result));
2994 }
2995 return resultobj;
2996 fail:
2997 return NULL;
2998 }
2999
3000
3001 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3002 PyObject *resultobj;
3003 wxPalette *arg1 = (wxPalette *) 0 ;
3004 bool result;
3005 PyObject * obj0 = 0 ;
3006 char *kwnames[] = {
3007 (char *) "self", NULL
3008 };
3009
3010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
3011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3012 if (SWIG_arg_fail(1)) SWIG_fail;
3013 {
3014 PyThreadState* __tstate = wxPyBeginAllowThreads();
3015 result = (bool)(arg1)->Ok();
3016
3017 wxPyEndAllowThreads(__tstate);
3018 if (PyErr_Occurred()) SWIG_fail;
3019 }
3020 {
3021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3022 }
3023 return resultobj;
3024 fail:
3025 return NULL;
3026 }
3027
3028
3029 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3030 PyObject *obj;
3031 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3032 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3033 Py_INCREF(obj);
3034 return Py_BuildValue((char *)"");
3035 }
3036 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3037 PyObject *resultobj;
3038 wxColour *arg1 = 0 ;
3039 int arg2 = (int) 1 ;
3040 int arg3 = (int) wxSOLID ;
3041 wxPen *result;
3042 wxColour temp1 ;
3043 PyObject * obj0 = 0 ;
3044 PyObject * obj1 = 0 ;
3045 PyObject * obj2 = 0 ;
3046 char *kwnames[] = {
3047 (char *) "colour",(char *) "width",(char *) "style", NULL
3048 };
3049
3050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3051 {
3052 arg1 = &temp1;
3053 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3054 }
3055 if (obj1) {
3056 {
3057 arg2 = (int)(SWIG_As_int(obj1));
3058 if (SWIG_arg_fail(2)) SWIG_fail;
3059 }
3060 }
3061 if (obj2) {
3062 {
3063 arg3 = (int)(SWIG_As_int(obj2));
3064 if (SWIG_arg_fail(3)) SWIG_fail;
3065 }
3066 }
3067 {
3068 if (!wxPyCheckForApp()) SWIG_fail;
3069 PyThreadState* __tstate = wxPyBeginAllowThreads();
3070 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3071
3072 wxPyEndAllowThreads(__tstate);
3073 if (PyErr_Occurred()) SWIG_fail;
3074 }
3075 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3076 return resultobj;
3077 fail:
3078 return NULL;
3079 }
3080
3081
3082 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3083 PyObject *resultobj;
3084 wxPen *arg1 = (wxPen *) 0 ;
3085 PyObject * obj0 = 0 ;
3086 char *kwnames[] = {
3087 (char *) "self", NULL
3088 };
3089
3090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3092 if (SWIG_arg_fail(1)) SWIG_fail;
3093 {
3094 PyThreadState* __tstate = wxPyBeginAllowThreads();
3095 delete arg1;
3096
3097 wxPyEndAllowThreads(__tstate);
3098 if (PyErr_Occurred()) SWIG_fail;
3099 }
3100 Py_INCREF(Py_None); resultobj = Py_None;
3101 return resultobj;
3102 fail:
3103 return NULL;
3104 }
3105
3106
3107 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3108 PyObject *resultobj;
3109 wxPen *arg1 = (wxPen *) 0 ;
3110 int result;
3111 PyObject * obj0 = 0 ;
3112 char *kwnames[] = {
3113 (char *) "self", NULL
3114 };
3115
3116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3118 if (SWIG_arg_fail(1)) SWIG_fail;
3119 {
3120 PyThreadState* __tstate = wxPyBeginAllowThreads();
3121 result = (int)(arg1)->GetCap();
3122
3123 wxPyEndAllowThreads(__tstate);
3124 if (PyErr_Occurred()) SWIG_fail;
3125 }
3126 {
3127 resultobj = SWIG_From_int((int)(result));
3128 }
3129 return resultobj;
3130 fail:
3131 return NULL;
3132 }
3133
3134
3135 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3136 PyObject *resultobj;
3137 wxPen *arg1 = (wxPen *) 0 ;
3138 wxColour result;
3139 PyObject * obj0 = 0 ;
3140 char *kwnames[] = {
3141 (char *) "self", NULL
3142 };
3143
3144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3146 if (SWIG_arg_fail(1)) SWIG_fail;
3147 {
3148 PyThreadState* __tstate = wxPyBeginAllowThreads();
3149 result = (arg1)->GetColour();
3150
3151 wxPyEndAllowThreads(__tstate);
3152 if (PyErr_Occurred()) SWIG_fail;
3153 }
3154 {
3155 wxColour * resultptr;
3156 resultptr = new wxColour((wxColour &)(result));
3157 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3158 }
3159 return resultobj;
3160 fail:
3161 return NULL;
3162 }
3163
3164
3165 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3166 PyObject *resultobj;
3167 wxPen *arg1 = (wxPen *) 0 ;
3168 int result;
3169 PyObject * obj0 = 0 ;
3170 char *kwnames[] = {
3171 (char *) "self", NULL
3172 };
3173
3174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3176 if (SWIG_arg_fail(1)) SWIG_fail;
3177 {
3178 PyThreadState* __tstate = wxPyBeginAllowThreads();
3179 result = (int)(arg1)->GetJoin();
3180
3181 wxPyEndAllowThreads(__tstate);
3182 if (PyErr_Occurred()) SWIG_fail;
3183 }
3184 {
3185 resultobj = SWIG_From_int((int)(result));
3186 }
3187 return resultobj;
3188 fail:
3189 return NULL;
3190 }
3191
3192
3193 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3194 PyObject *resultobj;
3195 wxPen *arg1 = (wxPen *) 0 ;
3196 int result;
3197 PyObject * obj0 = 0 ;
3198 char *kwnames[] = {
3199 (char *) "self", NULL
3200 };
3201
3202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3204 if (SWIG_arg_fail(1)) SWIG_fail;
3205 {
3206 PyThreadState* __tstate = wxPyBeginAllowThreads();
3207 result = (int)(arg1)->GetStyle();
3208
3209 wxPyEndAllowThreads(__tstate);
3210 if (PyErr_Occurred()) SWIG_fail;
3211 }
3212 {
3213 resultobj = SWIG_From_int((int)(result));
3214 }
3215 return resultobj;
3216 fail:
3217 return NULL;
3218 }
3219
3220
3221 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3222 PyObject *resultobj;
3223 wxPen *arg1 = (wxPen *) 0 ;
3224 int result;
3225 PyObject * obj0 = 0 ;
3226 char *kwnames[] = {
3227 (char *) "self", NULL
3228 };
3229
3230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3232 if (SWIG_arg_fail(1)) SWIG_fail;
3233 {
3234 PyThreadState* __tstate = wxPyBeginAllowThreads();
3235 result = (int)(arg1)->GetWidth();
3236
3237 wxPyEndAllowThreads(__tstate);
3238 if (PyErr_Occurred()) SWIG_fail;
3239 }
3240 {
3241 resultobj = SWIG_From_int((int)(result));
3242 }
3243 return resultobj;
3244 fail:
3245 return NULL;
3246 }
3247
3248
3249 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3250 PyObject *resultobj;
3251 wxPen *arg1 = (wxPen *) 0 ;
3252 bool result;
3253 PyObject * obj0 = 0 ;
3254 char *kwnames[] = {
3255 (char *) "self", NULL
3256 };
3257
3258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3260 if (SWIG_arg_fail(1)) SWIG_fail;
3261 {
3262 PyThreadState* __tstate = wxPyBeginAllowThreads();
3263 result = (bool)(arg1)->Ok();
3264
3265 wxPyEndAllowThreads(__tstate);
3266 if (PyErr_Occurred()) SWIG_fail;
3267 }
3268 {
3269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3270 }
3271 return resultobj;
3272 fail:
3273 return NULL;
3274 }
3275
3276
3277 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3278 PyObject *resultobj;
3279 wxPen *arg1 = (wxPen *) 0 ;
3280 int arg2 ;
3281 PyObject * obj0 = 0 ;
3282 PyObject * obj1 = 0 ;
3283 char *kwnames[] = {
3284 (char *) "self",(char *) "cap_style", NULL
3285 };
3286
3287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3289 if (SWIG_arg_fail(1)) SWIG_fail;
3290 {
3291 arg2 = (int)(SWIG_As_int(obj1));
3292 if (SWIG_arg_fail(2)) SWIG_fail;
3293 }
3294 {
3295 PyThreadState* __tstate = wxPyBeginAllowThreads();
3296 (arg1)->SetCap(arg2);
3297
3298 wxPyEndAllowThreads(__tstate);
3299 if (PyErr_Occurred()) SWIG_fail;
3300 }
3301 Py_INCREF(Py_None); resultobj = Py_None;
3302 return resultobj;
3303 fail:
3304 return NULL;
3305 }
3306
3307
3308 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3309 PyObject *resultobj;
3310 wxPen *arg1 = (wxPen *) 0 ;
3311 wxColour *arg2 = 0 ;
3312 wxColour temp2 ;
3313 PyObject * obj0 = 0 ;
3314 PyObject * obj1 = 0 ;
3315 char *kwnames[] = {
3316 (char *) "self",(char *) "colour", NULL
3317 };
3318
3319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3321 if (SWIG_arg_fail(1)) SWIG_fail;
3322 {
3323 arg2 = &temp2;
3324 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3325 }
3326 {
3327 PyThreadState* __tstate = wxPyBeginAllowThreads();
3328 (arg1)->SetColour(*arg2);
3329
3330 wxPyEndAllowThreads(__tstate);
3331 if (PyErr_Occurred()) SWIG_fail;
3332 }
3333 Py_INCREF(Py_None); resultobj = Py_None;
3334 return resultobj;
3335 fail:
3336 return NULL;
3337 }
3338
3339
3340 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3341 PyObject *resultobj;
3342 wxPen *arg1 = (wxPen *) 0 ;
3343 int arg2 ;
3344 PyObject * obj0 = 0 ;
3345 PyObject * obj1 = 0 ;
3346 char *kwnames[] = {
3347 (char *) "self",(char *) "join_style", NULL
3348 };
3349
3350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3352 if (SWIG_arg_fail(1)) SWIG_fail;
3353 {
3354 arg2 = (int)(SWIG_As_int(obj1));
3355 if (SWIG_arg_fail(2)) SWIG_fail;
3356 }
3357 {
3358 PyThreadState* __tstate = wxPyBeginAllowThreads();
3359 (arg1)->SetJoin(arg2);
3360
3361 wxPyEndAllowThreads(__tstate);
3362 if (PyErr_Occurred()) SWIG_fail;
3363 }
3364 Py_INCREF(Py_None); resultobj = Py_None;
3365 return resultobj;
3366 fail:
3367 return NULL;
3368 }
3369
3370
3371 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3372 PyObject *resultobj;
3373 wxPen *arg1 = (wxPen *) 0 ;
3374 int arg2 ;
3375 PyObject * obj0 = 0 ;
3376 PyObject * obj1 = 0 ;
3377 char *kwnames[] = {
3378 (char *) "self",(char *) "style", NULL
3379 };
3380
3381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3383 if (SWIG_arg_fail(1)) SWIG_fail;
3384 {
3385 arg2 = (int)(SWIG_As_int(obj1));
3386 if (SWIG_arg_fail(2)) SWIG_fail;
3387 }
3388 {
3389 PyThreadState* __tstate = wxPyBeginAllowThreads();
3390 (arg1)->SetStyle(arg2);
3391
3392 wxPyEndAllowThreads(__tstate);
3393 if (PyErr_Occurred()) SWIG_fail;
3394 }
3395 Py_INCREF(Py_None); resultobj = Py_None;
3396 return resultobj;
3397 fail:
3398 return NULL;
3399 }
3400
3401
3402 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3403 PyObject *resultobj;
3404 wxPen *arg1 = (wxPen *) 0 ;
3405 int arg2 ;
3406 PyObject * obj0 = 0 ;
3407 PyObject * obj1 = 0 ;
3408 char *kwnames[] = {
3409 (char *) "self",(char *) "width", NULL
3410 };
3411
3412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3414 if (SWIG_arg_fail(1)) SWIG_fail;
3415 {
3416 arg2 = (int)(SWIG_As_int(obj1));
3417 if (SWIG_arg_fail(2)) SWIG_fail;
3418 }
3419 {
3420 PyThreadState* __tstate = wxPyBeginAllowThreads();
3421 (arg1)->SetWidth(arg2);
3422
3423 wxPyEndAllowThreads(__tstate);
3424 if (PyErr_Occurred()) SWIG_fail;
3425 }
3426 Py_INCREF(Py_None); resultobj = Py_None;
3427 return resultobj;
3428 fail:
3429 return NULL;
3430 }
3431
3432
3433 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3434 PyObject *resultobj;
3435 wxPen *arg1 = (wxPen *) 0 ;
3436 int arg2 ;
3437 wxDash *arg3 = (wxDash *) 0 ;
3438 PyObject * obj0 = 0 ;
3439 PyObject * obj1 = 0 ;
3440 char *kwnames[] = {
3441 (char *) "self",(char *) "dashes", NULL
3442 };
3443
3444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3446 if (SWIG_arg_fail(1)) SWIG_fail;
3447 {
3448 arg2 = PyList_Size(obj1);
3449 arg3 = (wxDash*)byte_LIST_helper(obj1);
3450 if (arg3 == NULL) SWIG_fail;
3451 }
3452 {
3453 PyThreadState* __tstate = wxPyBeginAllowThreads();
3454 (arg1)->SetDashes(arg2,arg3);
3455
3456 wxPyEndAllowThreads(__tstate);
3457 if (PyErr_Occurred()) SWIG_fail;
3458 }
3459 Py_INCREF(Py_None); resultobj = Py_None;
3460 {
3461 if (arg3) delete [] arg3;
3462 }
3463 return resultobj;
3464 fail:
3465 {
3466 if (arg3) delete [] arg3;
3467 }
3468 return NULL;
3469 }
3470
3471
3472 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3473 PyObject *resultobj;
3474 wxPen *arg1 = (wxPen *) 0 ;
3475 PyObject *result;
3476 PyObject * obj0 = 0 ;
3477 char *kwnames[] = {
3478 (char *) "self", NULL
3479 };
3480
3481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3483 if (SWIG_arg_fail(1)) SWIG_fail;
3484 {
3485 PyThreadState* __tstate = wxPyBeginAllowThreads();
3486 result = (PyObject *)wxPen_GetDashes(arg1);
3487
3488 wxPyEndAllowThreads(__tstate);
3489 if (PyErr_Occurred()) SWIG_fail;
3490 }
3491 resultobj = result;
3492 return resultobj;
3493 fail:
3494 return NULL;
3495 }
3496
3497
3498 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3499 PyObject *resultobj;
3500 wxPen *arg1 = (wxPen *) 0 ;
3501 PyObject *arg2 = (PyObject *) 0 ;
3502 PyObject *arg3 = (PyObject *) 0 ;
3503 PyObject * obj0 = 0 ;
3504 PyObject * obj1 = 0 ;
3505 PyObject * obj2 = 0 ;
3506 char *kwnames[] = {
3507 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3508 };
3509
3510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3512 if (SWIG_arg_fail(1)) SWIG_fail;
3513 arg2 = obj1;
3514 arg3 = obj2;
3515 {
3516 PyThreadState* __tstate = wxPyBeginAllowThreads();
3517 wxPen__SetDashes(arg1,arg2,arg3);
3518
3519 wxPyEndAllowThreads(__tstate);
3520 if (PyErr_Occurred()) SWIG_fail;
3521 }
3522 Py_INCREF(Py_None); resultobj = Py_None;
3523 return resultobj;
3524 fail:
3525 return NULL;
3526 }
3527
3528
3529 static PyObject *_wrap_Pen_GetDashCount(PyObject *, PyObject *args, PyObject *kwargs) {
3530 PyObject *resultobj;
3531 wxPen *arg1 = (wxPen *) 0 ;
3532 int result;
3533 PyObject * obj0 = 0 ;
3534 char *kwnames[] = {
3535 (char *) "self", NULL
3536 };
3537
3538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashCount",kwnames,&obj0)) goto fail;
3539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3540 if (SWIG_arg_fail(1)) SWIG_fail;
3541 {
3542 PyThreadState* __tstate = wxPyBeginAllowThreads();
3543 result = (int)((wxPen const *)arg1)->GetDashCount();
3544
3545 wxPyEndAllowThreads(__tstate);
3546 if (PyErr_Occurred()) SWIG_fail;
3547 }
3548 {
3549 resultobj = SWIG_From_int((int)(result));
3550 }
3551 return resultobj;
3552 fail:
3553 return NULL;
3554 }
3555
3556
3557 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3558 PyObject *resultobj;
3559 wxPen *arg1 = (wxPen *) 0 ;
3560 wxPen *arg2 = (wxPen *) 0 ;
3561 bool result;
3562 PyObject * obj0 = 0 ;
3563 PyObject * obj1 = 0 ;
3564 char *kwnames[] = {
3565 (char *) "self",(char *) "other", NULL
3566 };
3567
3568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3570 if (SWIG_arg_fail(1)) SWIG_fail;
3571 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3572 if (SWIG_arg_fail(2)) SWIG_fail;
3573 {
3574 PyThreadState* __tstate = wxPyBeginAllowThreads();
3575 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3576
3577 wxPyEndAllowThreads(__tstate);
3578 if (PyErr_Occurred()) SWIG_fail;
3579 }
3580 {
3581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3582 }
3583 return resultobj;
3584 fail:
3585 return NULL;
3586 }
3587
3588
3589 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3590 PyObject *resultobj;
3591 wxPen *arg1 = (wxPen *) 0 ;
3592 wxPen *arg2 = (wxPen *) 0 ;
3593 bool result;
3594 PyObject * obj0 = 0 ;
3595 PyObject * obj1 = 0 ;
3596 char *kwnames[] = {
3597 (char *) "self",(char *) "other", NULL
3598 };
3599
3600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3602 if (SWIG_arg_fail(1)) SWIG_fail;
3603 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3604 if (SWIG_arg_fail(2)) SWIG_fail;
3605 {
3606 PyThreadState* __tstate = wxPyBeginAllowThreads();
3607 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3608
3609 wxPyEndAllowThreads(__tstate);
3610 if (PyErr_Occurred()) SWIG_fail;
3611 }
3612 {
3613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3614 }
3615 return resultobj;
3616 fail:
3617 return NULL;
3618 }
3619
3620
3621 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3622 PyObject *obj;
3623 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3624 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3625 Py_INCREF(obj);
3626 return Py_BuildValue((char *)"");
3627 }
3628 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3629 PyObject *resultobj;
3630 wxColour *arg1 = 0 ;
3631 int arg2 = (int) wxSOLID ;
3632 wxBrush *result;
3633 wxColour temp1 ;
3634 PyObject * obj0 = 0 ;
3635 PyObject * obj1 = 0 ;
3636 char *kwnames[] = {
3637 (char *) "colour",(char *) "style", NULL
3638 };
3639
3640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3641 {
3642 arg1 = &temp1;
3643 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3644 }
3645 if (obj1) {
3646 {
3647 arg2 = (int)(SWIG_As_int(obj1));
3648 if (SWIG_arg_fail(2)) SWIG_fail;
3649 }
3650 }
3651 {
3652 if (!wxPyCheckForApp()) SWIG_fail;
3653 PyThreadState* __tstate = wxPyBeginAllowThreads();
3654 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3655
3656 wxPyEndAllowThreads(__tstate);
3657 if (PyErr_Occurred()) SWIG_fail;
3658 }
3659 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3660 return resultobj;
3661 fail:
3662 return NULL;
3663 }
3664
3665
3666 static PyObject *_wrap_new_BrushFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3667 PyObject *resultobj;
3668 wxBitmap *arg1 = 0 ;
3669 wxBrush *result;
3670 PyObject * obj0 = 0 ;
3671 char *kwnames[] = {
3672 (char *) "stippleBitmap", NULL
3673 };
3674
3675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BrushFromBitmap",kwnames,&obj0)) goto fail;
3676 {
3677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3678 if (SWIG_arg_fail(1)) SWIG_fail;
3679 if (arg1 == NULL) {
3680 SWIG_null_ref("wxBitmap");
3681 }
3682 if (SWIG_arg_fail(1)) SWIG_fail;
3683 }
3684 {
3685 if (!wxPyCheckForApp()) SWIG_fail;
3686 PyThreadState* __tstate = wxPyBeginAllowThreads();
3687 result = (wxBrush *)new wxBrush((wxBitmap const &)*arg1);
3688
3689 wxPyEndAllowThreads(__tstate);
3690 if (PyErr_Occurred()) SWIG_fail;
3691 }
3692 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3693 return resultobj;
3694 fail:
3695 return NULL;
3696 }
3697
3698
3699 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3700 PyObject *resultobj;
3701 wxBrush *arg1 = (wxBrush *) 0 ;
3702 PyObject * obj0 = 0 ;
3703 char *kwnames[] = {
3704 (char *) "self", NULL
3705 };
3706
3707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3709 if (SWIG_arg_fail(1)) SWIG_fail;
3710 {
3711 PyThreadState* __tstate = wxPyBeginAllowThreads();
3712 delete arg1;
3713
3714 wxPyEndAllowThreads(__tstate);
3715 if (PyErr_Occurred()) SWIG_fail;
3716 }
3717 Py_INCREF(Py_None); resultobj = Py_None;
3718 return resultobj;
3719 fail:
3720 return NULL;
3721 }
3722
3723
3724 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3725 PyObject *resultobj;
3726 wxBrush *arg1 = (wxBrush *) 0 ;
3727 wxColour *arg2 = 0 ;
3728 wxColour temp2 ;
3729 PyObject * obj0 = 0 ;
3730 PyObject * obj1 = 0 ;
3731 char *kwnames[] = {
3732 (char *) "self",(char *) "col", NULL
3733 };
3734
3735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3737 if (SWIG_arg_fail(1)) SWIG_fail;
3738 {
3739 arg2 = &temp2;
3740 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3741 }
3742 {
3743 PyThreadState* __tstate = wxPyBeginAllowThreads();
3744 (arg1)->SetColour((wxColour const &)*arg2);
3745
3746 wxPyEndAllowThreads(__tstate);
3747 if (PyErr_Occurred()) SWIG_fail;
3748 }
3749 Py_INCREF(Py_None); resultobj = Py_None;
3750 return resultobj;
3751 fail:
3752 return NULL;
3753 }
3754
3755
3756 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3757 PyObject *resultobj;
3758 wxBrush *arg1 = (wxBrush *) 0 ;
3759 int arg2 ;
3760 PyObject * obj0 = 0 ;
3761 PyObject * obj1 = 0 ;
3762 char *kwnames[] = {
3763 (char *) "self",(char *) "style", NULL
3764 };
3765
3766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3768 if (SWIG_arg_fail(1)) SWIG_fail;
3769 {
3770 arg2 = (int)(SWIG_As_int(obj1));
3771 if (SWIG_arg_fail(2)) SWIG_fail;
3772 }
3773 {
3774 PyThreadState* __tstate = wxPyBeginAllowThreads();
3775 (arg1)->SetStyle(arg2);
3776
3777 wxPyEndAllowThreads(__tstate);
3778 if (PyErr_Occurred()) SWIG_fail;
3779 }
3780 Py_INCREF(Py_None); resultobj = Py_None;
3781 return resultobj;
3782 fail:
3783 return NULL;
3784 }
3785
3786
3787 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3788 PyObject *resultobj;
3789 wxBrush *arg1 = (wxBrush *) 0 ;
3790 wxBitmap *arg2 = 0 ;
3791 PyObject * obj0 = 0 ;
3792 PyObject * obj1 = 0 ;
3793 char *kwnames[] = {
3794 (char *) "self",(char *) "stipple", NULL
3795 };
3796
3797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3799 if (SWIG_arg_fail(1)) SWIG_fail;
3800 {
3801 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3802 if (SWIG_arg_fail(2)) SWIG_fail;
3803 if (arg2 == NULL) {
3804 SWIG_null_ref("wxBitmap");
3805 }
3806 if (SWIG_arg_fail(2)) SWIG_fail;
3807 }
3808 {
3809 PyThreadState* __tstate = wxPyBeginAllowThreads();
3810 (arg1)->SetStipple((wxBitmap const &)*arg2);
3811
3812 wxPyEndAllowThreads(__tstate);
3813 if (PyErr_Occurred()) SWIG_fail;
3814 }
3815 Py_INCREF(Py_None); resultobj = Py_None;
3816 return resultobj;
3817 fail:
3818 return NULL;
3819 }
3820
3821
3822 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3823 PyObject *resultobj;
3824 wxBrush *arg1 = (wxBrush *) 0 ;
3825 wxColour result;
3826 PyObject * obj0 = 0 ;
3827 char *kwnames[] = {
3828 (char *) "self", NULL
3829 };
3830
3831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3833 if (SWIG_arg_fail(1)) SWIG_fail;
3834 {
3835 PyThreadState* __tstate = wxPyBeginAllowThreads();
3836 result = ((wxBrush const *)arg1)->GetColour();
3837
3838 wxPyEndAllowThreads(__tstate);
3839 if (PyErr_Occurred()) SWIG_fail;
3840 }
3841 {
3842 wxColour * resultptr;
3843 resultptr = new wxColour((wxColour &)(result));
3844 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3845 }
3846 return resultobj;
3847 fail:
3848 return NULL;
3849 }
3850
3851
3852 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3853 PyObject *resultobj;
3854 wxBrush *arg1 = (wxBrush *) 0 ;
3855 int result;
3856 PyObject * obj0 = 0 ;
3857 char *kwnames[] = {
3858 (char *) "self", NULL
3859 };
3860
3861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3863 if (SWIG_arg_fail(1)) SWIG_fail;
3864 {
3865 PyThreadState* __tstate = wxPyBeginAllowThreads();
3866 result = (int)((wxBrush const *)arg1)->GetStyle();
3867
3868 wxPyEndAllowThreads(__tstate);
3869 if (PyErr_Occurred()) SWIG_fail;
3870 }
3871 {
3872 resultobj = SWIG_From_int((int)(result));
3873 }
3874 return resultobj;
3875 fail:
3876 return NULL;
3877 }
3878
3879
3880 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3881 PyObject *resultobj;
3882 wxBrush *arg1 = (wxBrush *) 0 ;
3883 wxBitmap *result;
3884 PyObject * obj0 = 0 ;
3885 char *kwnames[] = {
3886 (char *) "self", NULL
3887 };
3888
3889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3891 if (SWIG_arg_fail(1)) SWIG_fail;
3892 {
3893 PyThreadState* __tstate = wxPyBeginAllowThreads();
3894 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3895
3896 wxPyEndAllowThreads(__tstate);
3897 if (PyErr_Occurred()) SWIG_fail;
3898 }
3899 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3900 return resultobj;
3901 fail:
3902 return NULL;
3903 }
3904
3905
3906 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3907 PyObject *resultobj;
3908 wxBrush *arg1 = (wxBrush *) 0 ;
3909 bool result;
3910 PyObject * obj0 = 0 ;
3911 char *kwnames[] = {
3912 (char *) "self", NULL
3913 };
3914
3915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3917 if (SWIG_arg_fail(1)) SWIG_fail;
3918 {
3919 PyThreadState* __tstate = wxPyBeginAllowThreads();
3920 result = (bool)((wxBrush const *)arg1)->IsHatch();
3921
3922 wxPyEndAllowThreads(__tstate);
3923 if (PyErr_Occurred()) SWIG_fail;
3924 }
3925 {
3926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3927 }
3928 return resultobj;
3929 fail:
3930 return NULL;
3931 }
3932
3933
3934 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3935 PyObject *resultobj;
3936 wxBrush *arg1 = (wxBrush *) 0 ;
3937 bool result;
3938 PyObject * obj0 = 0 ;
3939 char *kwnames[] = {
3940 (char *) "self", NULL
3941 };
3942
3943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3945 if (SWIG_arg_fail(1)) SWIG_fail;
3946 {
3947 PyThreadState* __tstate = wxPyBeginAllowThreads();
3948 result = (bool)(arg1)->Ok();
3949
3950 wxPyEndAllowThreads(__tstate);
3951 if (PyErr_Occurred()) SWIG_fail;
3952 }
3953 {
3954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3955 }
3956 return resultobj;
3957 fail:
3958 return NULL;
3959 }
3960
3961
3962 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
3963 PyObject *obj;
3964 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3965 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
3966 Py_INCREF(obj);
3967 return Py_BuildValue((char *)"");
3968 }
3969 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3970 PyObject *resultobj;
3971 wxString *arg1 = 0 ;
3972 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
3973 wxBitmap *result;
3974 bool temp1 = false ;
3975 PyObject * obj0 = 0 ;
3976 PyObject * obj1 = 0 ;
3977 char *kwnames[] = {
3978 (char *) "name",(char *) "type", NULL
3979 };
3980
3981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
3982 {
3983 arg1 = wxString_in_helper(obj0);
3984 if (arg1 == NULL) SWIG_fail;
3985 temp1 = true;
3986 }
3987 if (obj1) {
3988 {
3989 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
3990 if (SWIG_arg_fail(2)) SWIG_fail;
3991 }
3992 }
3993 {
3994 if (!wxPyCheckForApp()) SWIG_fail;
3995 PyThreadState* __tstate = wxPyBeginAllowThreads();
3996 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
3997
3998 wxPyEndAllowThreads(__tstate);
3999 if (PyErr_Occurred()) SWIG_fail;
4000 }
4001 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4002 {
4003 if (temp1)
4004 delete arg1;
4005 }
4006 return resultobj;
4007 fail:
4008 {
4009 if (temp1)
4010 delete arg1;
4011 }
4012 return NULL;
4013 }
4014
4015
4016 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4017 PyObject *resultobj;
4018 wxBitmap *arg1 = (wxBitmap *) 0 ;
4019 PyObject * obj0 = 0 ;
4020 char *kwnames[] = {
4021 (char *) "self", NULL
4022 };
4023
4024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
4025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4026 if (SWIG_arg_fail(1)) SWIG_fail;
4027 {
4028 PyThreadState* __tstate = wxPyBeginAllowThreads();
4029 delete arg1;
4030
4031 wxPyEndAllowThreads(__tstate);
4032 if (PyErr_Occurred()) SWIG_fail;
4033 }
4034 Py_INCREF(Py_None); resultobj = Py_None;
4035 return resultobj;
4036 fail:
4037 return NULL;
4038 }
4039
4040
4041 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4042 PyObject *resultobj;
4043 int arg1 ;
4044 int arg2 ;
4045 int arg3 = (int) -1 ;
4046 wxBitmap *result;
4047 PyObject * obj0 = 0 ;
4048 PyObject * obj1 = 0 ;
4049 PyObject * obj2 = 0 ;
4050 char *kwnames[] = {
4051 (char *) "width",(char *) "height",(char *) "depth", NULL
4052 };
4053
4054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4055 {
4056 arg1 = (int)(SWIG_As_int(obj0));
4057 if (SWIG_arg_fail(1)) SWIG_fail;
4058 }
4059 {
4060 arg2 = (int)(SWIG_As_int(obj1));
4061 if (SWIG_arg_fail(2)) SWIG_fail;
4062 }
4063 if (obj2) {
4064 {
4065 arg3 = (int)(SWIG_As_int(obj2));
4066 if (SWIG_arg_fail(3)) SWIG_fail;
4067 }
4068 }
4069 {
4070 if (!wxPyCheckForApp()) SWIG_fail;
4071 PyThreadState* __tstate = wxPyBeginAllowThreads();
4072 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4073
4074 wxPyEndAllowThreads(__tstate);
4075 if (PyErr_Occurred()) SWIG_fail;
4076 }
4077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4078 return resultobj;
4079 fail:
4080 return NULL;
4081 }
4082
4083
4084 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4085 PyObject *resultobj;
4086 wxIcon *arg1 = 0 ;
4087 wxBitmap *result;
4088 PyObject * obj0 = 0 ;
4089 char *kwnames[] = {
4090 (char *) "icon", NULL
4091 };
4092
4093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4094 {
4095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4096 if (SWIG_arg_fail(1)) SWIG_fail;
4097 if (arg1 == NULL) {
4098 SWIG_null_ref("wxIcon");
4099 }
4100 if (SWIG_arg_fail(1)) SWIG_fail;
4101 }
4102 {
4103 if (!wxPyCheckForApp()) SWIG_fail;
4104 PyThreadState* __tstate = wxPyBeginAllowThreads();
4105 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4106
4107 wxPyEndAllowThreads(__tstate);
4108 if (PyErr_Occurred()) SWIG_fail;
4109 }
4110 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4111 return resultobj;
4112 fail:
4113 return NULL;
4114 }
4115
4116
4117 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4118 PyObject *resultobj;
4119 wxImage *arg1 = 0 ;
4120 int arg2 = (int) -1 ;
4121 wxBitmap *result;
4122 PyObject * obj0 = 0 ;
4123 PyObject * obj1 = 0 ;
4124 char *kwnames[] = {
4125 (char *) "image",(char *) "depth", NULL
4126 };
4127
4128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4129 {
4130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4131 if (SWIG_arg_fail(1)) SWIG_fail;
4132 if (arg1 == NULL) {
4133 SWIG_null_ref("wxImage");
4134 }
4135 if (SWIG_arg_fail(1)) SWIG_fail;
4136 }
4137 if (obj1) {
4138 {
4139 arg2 = (int)(SWIG_As_int(obj1));
4140 if (SWIG_arg_fail(2)) SWIG_fail;
4141 }
4142 }
4143 {
4144 if (!wxPyCheckForApp()) SWIG_fail;
4145 PyThreadState* __tstate = wxPyBeginAllowThreads();
4146 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4147
4148 wxPyEndAllowThreads(__tstate);
4149 if (PyErr_Occurred()) SWIG_fail;
4150 }
4151 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4152 return resultobj;
4153 fail:
4154 return NULL;
4155 }
4156
4157
4158 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4159 PyObject *resultobj;
4160 PyObject *arg1 = (PyObject *) 0 ;
4161 wxBitmap *result;
4162 PyObject * obj0 = 0 ;
4163 char *kwnames[] = {
4164 (char *) "listOfStrings", NULL
4165 };
4166
4167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4168 arg1 = obj0;
4169 {
4170 if (!wxPyCheckForApp()) SWIG_fail;
4171 PyThreadState* __tstate = wxPyBeginAllowThreads();
4172 result = (wxBitmap *)new_wxBitmap(arg1);
4173
4174 wxPyEndAllowThreads(__tstate);
4175 if (PyErr_Occurred()) SWIG_fail;
4176 }
4177 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4178 return resultobj;
4179 fail:
4180 return NULL;
4181 }
4182
4183
4184 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4185 PyObject *resultobj;
4186 PyObject *arg1 = (PyObject *) 0 ;
4187 int arg2 ;
4188 int arg3 ;
4189 int arg4 = (int) 1 ;
4190 wxBitmap *result;
4191 PyObject * obj0 = 0 ;
4192 PyObject * obj1 = 0 ;
4193 PyObject * obj2 = 0 ;
4194 PyObject * obj3 = 0 ;
4195 char *kwnames[] = {
4196 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4197 };
4198
4199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4200 arg1 = obj0;
4201 {
4202 arg2 = (int)(SWIG_As_int(obj1));
4203 if (SWIG_arg_fail(2)) SWIG_fail;
4204 }
4205 {
4206 arg3 = (int)(SWIG_As_int(obj2));
4207 if (SWIG_arg_fail(3)) SWIG_fail;
4208 }
4209 if (obj3) {
4210 {
4211 arg4 = (int)(SWIG_As_int(obj3));
4212 if (SWIG_arg_fail(4)) SWIG_fail;
4213 }
4214 }
4215 {
4216 if (!wxPyCheckForApp()) SWIG_fail;
4217 PyThreadState* __tstate = wxPyBeginAllowThreads();
4218 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4219
4220 wxPyEndAllowThreads(__tstate);
4221 if (PyErr_Occurred()) SWIG_fail;
4222 }
4223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4224 return resultobj;
4225 fail:
4226 return NULL;
4227 }
4228
4229
4230 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4231 PyObject *resultobj;
4232 wxBitmap *arg1 = (wxBitmap *) 0 ;
4233 bool result;
4234 PyObject * obj0 = 0 ;
4235 char *kwnames[] = {
4236 (char *) "self", NULL
4237 };
4238
4239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4241 if (SWIG_arg_fail(1)) SWIG_fail;
4242 {
4243 PyThreadState* __tstate = wxPyBeginAllowThreads();
4244 result = (bool)(arg1)->Ok();
4245
4246 wxPyEndAllowThreads(__tstate);
4247 if (PyErr_Occurred()) SWIG_fail;
4248 }
4249 {
4250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4251 }
4252 return resultobj;
4253 fail:
4254 return NULL;
4255 }
4256
4257
4258 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4259 PyObject *resultobj;
4260 wxBitmap *arg1 = (wxBitmap *) 0 ;
4261 int result;
4262 PyObject * obj0 = 0 ;
4263 char *kwnames[] = {
4264 (char *) "self", NULL
4265 };
4266
4267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4269 if (SWIG_arg_fail(1)) SWIG_fail;
4270 {
4271 PyThreadState* __tstate = wxPyBeginAllowThreads();
4272 result = (int)(arg1)->GetWidth();
4273
4274 wxPyEndAllowThreads(__tstate);
4275 if (PyErr_Occurred()) SWIG_fail;
4276 }
4277 {
4278 resultobj = SWIG_From_int((int)(result));
4279 }
4280 return resultobj;
4281 fail:
4282 return NULL;
4283 }
4284
4285
4286 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4287 PyObject *resultobj;
4288 wxBitmap *arg1 = (wxBitmap *) 0 ;
4289 int result;
4290 PyObject * obj0 = 0 ;
4291 char *kwnames[] = {
4292 (char *) "self", NULL
4293 };
4294
4295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4297 if (SWIG_arg_fail(1)) SWIG_fail;
4298 {
4299 PyThreadState* __tstate = wxPyBeginAllowThreads();
4300 result = (int)(arg1)->GetHeight();
4301
4302 wxPyEndAllowThreads(__tstate);
4303 if (PyErr_Occurred()) SWIG_fail;
4304 }
4305 {
4306 resultobj = SWIG_From_int((int)(result));
4307 }
4308 return resultobj;
4309 fail:
4310 return NULL;
4311 }
4312
4313
4314 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4315 PyObject *resultobj;
4316 wxBitmap *arg1 = (wxBitmap *) 0 ;
4317 int result;
4318 PyObject * obj0 = 0 ;
4319 char *kwnames[] = {
4320 (char *) "self", NULL
4321 };
4322
4323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4325 if (SWIG_arg_fail(1)) SWIG_fail;
4326 {
4327 PyThreadState* __tstate = wxPyBeginAllowThreads();
4328 result = (int)(arg1)->GetDepth();
4329
4330 wxPyEndAllowThreads(__tstate);
4331 if (PyErr_Occurred()) SWIG_fail;
4332 }
4333 {
4334 resultobj = SWIG_From_int((int)(result));
4335 }
4336 return resultobj;
4337 fail:
4338 return NULL;
4339 }
4340
4341
4342 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4343 PyObject *resultobj;
4344 wxBitmap *arg1 = (wxBitmap *) 0 ;
4345 wxSize result;
4346 PyObject * obj0 = 0 ;
4347 char *kwnames[] = {
4348 (char *) "self", NULL
4349 };
4350
4351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4353 if (SWIG_arg_fail(1)) SWIG_fail;
4354 {
4355 PyThreadState* __tstate = wxPyBeginAllowThreads();
4356 result = wxBitmap_GetSize(arg1);
4357
4358 wxPyEndAllowThreads(__tstate);
4359 if (PyErr_Occurred()) SWIG_fail;
4360 }
4361 {
4362 wxSize * resultptr;
4363 resultptr = new wxSize((wxSize &)(result));
4364 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4365 }
4366 return resultobj;
4367 fail:
4368 return NULL;
4369 }
4370
4371
4372 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4373 PyObject *resultobj;
4374 wxBitmap *arg1 = (wxBitmap *) 0 ;
4375 SwigValueWrapper<wxImage > result;
4376 PyObject * obj0 = 0 ;
4377 char *kwnames[] = {
4378 (char *) "self", NULL
4379 };
4380
4381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4383 if (SWIG_arg_fail(1)) SWIG_fail;
4384 {
4385 PyThreadState* __tstate = wxPyBeginAllowThreads();
4386 result = ((wxBitmap const *)arg1)->ConvertToImage();
4387
4388 wxPyEndAllowThreads(__tstate);
4389 if (PyErr_Occurred()) SWIG_fail;
4390 }
4391 {
4392 wxImage * resultptr;
4393 resultptr = new wxImage((wxImage &)(result));
4394 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4395 }
4396 return resultobj;
4397 fail:
4398 return NULL;
4399 }
4400
4401
4402 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4403 PyObject *resultobj;
4404 wxBitmap *arg1 = (wxBitmap *) 0 ;
4405 wxMask *result;
4406 PyObject * obj0 = 0 ;
4407 char *kwnames[] = {
4408 (char *) "self", NULL
4409 };
4410
4411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4413 if (SWIG_arg_fail(1)) SWIG_fail;
4414 {
4415 PyThreadState* __tstate = wxPyBeginAllowThreads();
4416 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4417
4418 wxPyEndAllowThreads(__tstate);
4419 if (PyErr_Occurred()) SWIG_fail;
4420 }
4421 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4422 return resultobj;
4423 fail:
4424 return NULL;
4425 }
4426
4427
4428 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4429 PyObject *resultobj;
4430 wxBitmap *arg1 = (wxBitmap *) 0 ;
4431 wxMask *arg2 = (wxMask *) 0 ;
4432 PyObject * obj0 = 0 ;
4433 PyObject * obj1 = 0 ;
4434 char *kwnames[] = {
4435 (char *) "self",(char *) "mask", NULL
4436 };
4437
4438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4440 if (SWIG_arg_fail(1)) SWIG_fail;
4441 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4442 if (SWIG_arg_fail(2)) SWIG_fail;
4443 {
4444 PyThreadState* __tstate = wxPyBeginAllowThreads();
4445 (arg1)->SetMask(arg2);
4446
4447 wxPyEndAllowThreads(__tstate);
4448 if (PyErr_Occurred()) SWIG_fail;
4449 }
4450 Py_INCREF(Py_None); resultobj = Py_None;
4451 return resultobj;
4452 fail:
4453 return NULL;
4454 }
4455
4456
4457 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4458 PyObject *resultobj;
4459 wxBitmap *arg1 = (wxBitmap *) 0 ;
4460 wxColour *arg2 = 0 ;
4461 wxColour temp2 ;
4462 PyObject * obj0 = 0 ;
4463 PyObject * obj1 = 0 ;
4464 char *kwnames[] = {
4465 (char *) "self",(char *) "colour", NULL
4466 };
4467
4468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4470 if (SWIG_arg_fail(1)) SWIG_fail;
4471 {
4472 arg2 = &temp2;
4473 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4474 }
4475 {
4476 PyThreadState* __tstate = wxPyBeginAllowThreads();
4477 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4478
4479 wxPyEndAllowThreads(__tstate);
4480 if (PyErr_Occurred()) SWIG_fail;
4481 }
4482 Py_INCREF(Py_None); resultobj = Py_None;
4483 return resultobj;
4484 fail:
4485 return NULL;
4486 }
4487
4488
4489 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4490 PyObject *resultobj;
4491 wxBitmap *arg1 = (wxBitmap *) 0 ;
4492 wxRect *arg2 = 0 ;
4493 SwigValueWrapper<wxBitmap > result;
4494 wxRect temp2 ;
4495 PyObject * obj0 = 0 ;
4496 PyObject * obj1 = 0 ;
4497 char *kwnames[] = {
4498 (char *) "self",(char *) "rect", NULL
4499 };
4500
4501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4503 if (SWIG_arg_fail(1)) SWIG_fail;
4504 {
4505 arg2 = &temp2;
4506 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4507 }
4508 {
4509 PyThreadState* __tstate = wxPyBeginAllowThreads();
4510 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4511
4512 wxPyEndAllowThreads(__tstate);
4513 if (PyErr_Occurred()) SWIG_fail;
4514 }
4515 {
4516 wxBitmap * resultptr;
4517 resultptr = new wxBitmap((wxBitmap &)(result));
4518 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4519 }
4520 return resultobj;
4521 fail:
4522 return NULL;
4523 }
4524
4525
4526 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4527 PyObject *resultobj;
4528 wxBitmap *arg1 = (wxBitmap *) 0 ;
4529 wxString *arg2 = 0 ;
4530 wxBitmapType arg3 ;
4531 wxPalette *arg4 = (wxPalette *) NULL ;
4532 bool result;
4533 bool temp2 = false ;
4534 PyObject * obj0 = 0 ;
4535 PyObject * obj1 = 0 ;
4536 PyObject * obj2 = 0 ;
4537 PyObject * obj3 = 0 ;
4538 char *kwnames[] = {
4539 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4540 };
4541
4542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4544 if (SWIG_arg_fail(1)) SWIG_fail;
4545 {
4546 arg2 = wxString_in_helper(obj1);
4547 if (arg2 == NULL) SWIG_fail;
4548 temp2 = true;
4549 }
4550 {
4551 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4552 if (SWIG_arg_fail(3)) SWIG_fail;
4553 }
4554 if (obj3) {
4555 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4556 if (SWIG_arg_fail(4)) SWIG_fail;
4557 }
4558 {
4559 PyThreadState* __tstate = wxPyBeginAllowThreads();
4560 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4561
4562 wxPyEndAllowThreads(__tstate);
4563 if (PyErr_Occurred()) SWIG_fail;
4564 }
4565 {
4566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4567 }
4568 {
4569 if (temp2)
4570 delete arg2;
4571 }
4572 return resultobj;
4573 fail:
4574 {
4575 if (temp2)
4576 delete arg2;
4577 }
4578 return NULL;
4579 }
4580
4581
4582 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4583 PyObject *resultobj;
4584 wxBitmap *arg1 = (wxBitmap *) 0 ;
4585 wxString *arg2 = 0 ;
4586 wxBitmapType arg3 ;
4587 bool result;
4588 bool temp2 = false ;
4589 PyObject * obj0 = 0 ;
4590 PyObject * obj1 = 0 ;
4591 PyObject * obj2 = 0 ;
4592 char *kwnames[] = {
4593 (char *) "self",(char *) "name",(char *) "type", NULL
4594 };
4595
4596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4598 if (SWIG_arg_fail(1)) SWIG_fail;
4599 {
4600 arg2 = wxString_in_helper(obj1);
4601 if (arg2 == NULL) SWIG_fail;
4602 temp2 = true;
4603 }
4604 {
4605 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4606 if (SWIG_arg_fail(3)) SWIG_fail;
4607 }
4608 {
4609 PyThreadState* __tstate = wxPyBeginAllowThreads();
4610 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4611
4612 wxPyEndAllowThreads(__tstate);
4613 if (PyErr_Occurred()) SWIG_fail;
4614 }
4615 {
4616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4617 }
4618 {
4619 if (temp2)
4620 delete arg2;
4621 }
4622 return resultobj;
4623 fail:
4624 {
4625 if (temp2)
4626 delete arg2;
4627 }
4628 return NULL;
4629 }
4630
4631
4632 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4633 PyObject *resultobj;
4634 wxBitmap *arg1 = (wxBitmap *) 0 ;
4635 wxPalette *result;
4636 PyObject * obj0 = 0 ;
4637 char *kwnames[] = {
4638 (char *) "self", NULL
4639 };
4640
4641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4643 if (SWIG_arg_fail(1)) SWIG_fail;
4644 {
4645 PyThreadState* __tstate = wxPyBeginAllowThreads();
4646 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4647
4648 wxPyEndAllowThreads(__tstate);
4649 if (PyErr_Occurred()) SWIG_fail;
4650 }
4651 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4652 return resultobj;
4653 fail:
4654 return NULL;
4655 }
4656
4657
4658 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4659 PyObject *resultobj;
4660 wxBitmap *arg1 = (wxBitmap *) 0 ;
4661 wxIcon *arg2 = 0 ;
4662 bool result;
4663 PyObject * obj0 = 0 ;
4664 PyObject * obj1 = 0 ;
4665 char *kwnames[] = {
4666 (char *) "self",(char *) "icon", NULL
4667 };
4668
4669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4671 if (SWIG_arg_fail(1)) SWIG_fail;
4672 {
4673 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4674 if (SWIG_arg_fail(2)) SWIG_fail;
4675 if (arg2 == NULL) {
4676 SWIG_null_ref("wxIcon");
4677 }
4678 if (SWIG_arg_fail(2)) SWIG_fail;
4679 }
4680 {
4681 PyThreadState* __tstate = wxPyBeginAllowThreads();
4682 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4683
4684 wxPyEndAllowThreads(__tstate);
4685 if (PyErr_Occurred()) SWIG_fail;
4686 }
4687 {
4688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4689 }
4690 return resultobj;
4691 fail:
4692 return NULL;
4693 }
4694
4695
4696 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4697 PyObject *resultobj;
4698 wxBitmap *arg1 = (wxBitmap *) 0 ;
4699 int arg2 ;
4700 PyObject * obj0 = 0 ;
4701 PyObject * obj1 = 0 ;
4702 char *kwnames[] = {
4703 (char *) "self",(char *) "height", NULL
4704 };
4705
4706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4708 if (SWIG_arg_fail(1)) SWIG_fail;
4709 {
4710 arg2 = (int)(SWIG_As_int(obj1));
4711 if (SWIG_arg_fail(2)) SWIG_fail;
4712 }
4713 {
4714 PyThreadState* __tstate = wxPyBeginAllowThreads();
4715 (arg1)->SetHeight(arg2);
4716
4717 wxPyEndAllowThreads(__tstate);
4718 if (PyErr_Occurred()) SWIG_fail;
4719 }
4720 Py_INCREF(Py_None); resultobj = Py_None;
4721 return resultobj;
4722 fail:
4723 return NULL;
4724 }
4725
4726
4727 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4728 PyObject *resultobj;
4729 wxBitmap *arg1 = (wxBitmap *) 0 ;
4730 int arg2 ;
4731 PyObject * obj0 = 0 ;
4732 PyObject * obj1 = 0 ;
4733 char *kwnames[] = {
4734 (char *) "self",(char *) "width", NULL
4735 };
4736
4737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4739 if (SWIG_arg_fail(1)) SWIG_fail;
4740 {
4741 arg2 = (int)(SWIG_As_int(obj1));
4742 if (SWIG_arg_fail(2)) SWIG_fail;
4743 }
4744 {
4745 PyThreadState* __tstate = wxPyBeginAllowThreads();
4746 (arg1)->SetWidth(arg2);
4747
4748 wxPyEndAllowThreads(__tstate);
4749 if (PyErr_Occurred()) SWIG_fail;
4750 }
4751 Py_INCREF(Py_None); resultobj = Py_None;
4752 return resultobj;
4753 fail:
4754 return NULL;
4755 }
4756
4757
4758 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4759 PyObject *resultobj;
4760 wxBitmap *arg1 = (wxBitmap *) 0 ;
4761 int arg2 ;
4762 PyObject * obj0 = 0 ;
4763 PyObject * obj1 = 0 ;
4764 char *kwnames[] = {
4765 (char *) "self",(char *) "depth", NULL
4766 };
4767
4768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4770 if (SWIG_arg_fail(1)) SWIG_fail;
4771 {
4772 arg2 = (int)(SWIG_As_int(obj1));
4773 if (SWIG_arg_fail(2)) SWIG_fail;
4774 }
4775 {
4776 PyThreadState* __tstate = wxPyBeginAllowThreads();
4777 (arg1)->SetDepth(arg2);
4778
4779 wxPyEndAllowThreads(__tstate);
4780 if (PyErr_Occurred()) SWIG_fail;
4781 }
4782 Py_INCREF(Py_None); resultobj = Py_None;
4783 return resultobj;
4784 fail:
4785 return NULL;
4786 }
4787
4788
4789 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4790 PyObject *resultobj;
4791 wxBitmap *arg1 = (wxBitmap *) 0 ;
4792 wxSize *arg2 = 0 ;
4793 wxSize temp2 ;
4794 PyObject * obj0 = 0 ;
4795 PyObject * obj1 = 0 ;
4796 char *kwnames[] = {
4797 (char *) "self",(char *) "size", NULL
4798 };
4799
4800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4802 if (SWIG_arg_fail(1)) SWIG_fail;
4803 {
4804 arg2 = &temp2;
4805 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4806 }
4807 {
4808 PyThreadState* __tstate = wxPyBeginAllowThreads();
4809 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4810
4811 wxPyEndAllowThreads(__tstate);
4812 if (PyErr_Occurred()) SWIG_fail;
4813 }
4814 Py_INCREF(Py_None); resultobj = Py_None;
4815 return resultobj;
4816 fail:
4817 return NULL;
4818 }
4819
4820
4821 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4822 PyObject *resultobj;
4823 wxBitmap *arg1 = (wxBitmap *) 0 ;
4824 wxBitmap *arg2 = (wxBitmap *) 0 ;
4825 bool result;
4826 PyObject * obj0 = 0 ;
4827 PyObject * obj1 = 0 ;
4828 char *kwnames[] = {
4829 (char *) "self",(char *) "other", NULL
4830 };
4831
4832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
4833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4834 if (SWIG_arg_fail(1)) SWIG_fail;
4835 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4836 if (SWIG_arg_fail(2)) SWIG_fail;
4837 {
4838 PyThreadState* __tstate = wxPyBeginAllowThreads();
4839 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
4840
4841 wxPyEndAllowThreads(__tstate);
4842 if (PyErr_Occurred()) SWIG_fail;
4843 }
4844 {
4845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4846 }
4847 return resultobj;
4848 fail:
4849 return NULL;
4850 }
4851
4852
4853 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4854 PyObject *resultobj;
4855 wxBitmap *arg1 = (wxBitmap *) 0 ;
4856 wxBitmap *arg2 = (wxBitmap *) 0 ;
4857 bool result;
4858 PyObject * obj0 = 0 ;
4859 PyObject * obj1 = 0 ;
4860 char *kwnames[] = {
4861 (char *) "self",(char *) "other", NULL
4862 };
4863
4864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
4865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4866 if (SWIG_arg_fail(1)) SWIG_fail;
4867 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4868 if (SWIG_arg_fail(2)) SWIG_fail;
4869 {
4870 PyThreadState* __tstate = wxPyBeginAllowThreads();
4871 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
4872
4873 wxPyEndAllowThreads(__tstate);
4874 if (PyErr_Occurred()) SWIG_fail;
4875 }
4876 {
4877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4878 }
4879 return resultobj;
4880 fail:
4881 return NULL;
4882 }
4883
4884
4885 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
4886 PyObject *obj;
4887 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4888 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
4889 Py_INCREF(obj);
4890 return Py_BuildValue((char *)"");
4891 }
4892 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
4893 PyObject *resultobj;
4894 wxBitmap *arg1 = 0 ;
4895 wxColour const &arg2_defvalue = wxNullColour ;
4896 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
4897 wxMask *result;
4898 wxColour temp2 ;
4899 PyObject * obj0 = 0 ;
4900 PyObject * obj1 = 0 ;
4901 char *kwnames[] = {
4902 (char *) "bitmap",(char *) "colour", NULL
4903 };
4904
4905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
4906 {
4907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4908 if (SWIG_arg_fail(1)) SWIG_fail;
4909 if (arg1 == NULL) {
4910 SWIG_null_ref("wxBitmap");
4911 }
4912 if (SWIG_arg_fail(1)) SWIG_fail;
4913 }
4914 if (obj1) {
4915 {
4916 arg2 = &temp2;
4917 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4918 }
4919 }
4920 {
4921 if (!wxPyCheckForApp()) SWIG_fail;
4922 PyThreadState* __tstate = wxPyBeginAllowThreads();
4923 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
4924
4925 wxPyEndAllowThreads(__tstate);
4926 if (PyErr_Occurred()) SWIG_fail;
4927 }
4928 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
4929 return resultobj;
4930 fail:
4931 return NULL;
4932 }
4933
4934
4935 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
4936 PyObject *obj;
4937 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4938 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
4939 Py_INCREF(obj);
4940 return Py_BuildValue((char *)"");
4941 }
4942 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
4943 PyObject *resultobj;
4944 wxString *arg1 = 0 ;
4945 wxBitmapType arg2 ;
4946 int arg3 = (int) -1 ;
4947 int arg4 = (int) -1 ;
4948 wxIcon *result;
4949 bool temp1 = false ;
4950 PyObject * obj0 = 0 ;
4951 PyObject * obj1 = 0 ;
4952 PyObject * obj2 = 0 ;
4953 PyObject * obj3 = 0 ;
4954 char *kwnames[] = {
4955 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
4956 };
4957
4958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4959 {
4960 arg1 = wxString_in_helper(obj0);
4961 if (arg1 == NULL) SWIG_fail;
4962 temp1 = true;
4963 }
4964 {
4965 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4966 if (SWIG_arg_fail(2)) SWIG_fail;
4967 }
4968 if (obj2) {
4969 {
4970 arg3 = (int)(SWIG_As_int(obj2));
4971 if (SWIG_arg_fail(3)) SWIG_fail;
4972 }
4973 }
4974 if (obj3) {
4975 {
4976 arg4 = (int)(SWIG_As_int(obj3));
4977 if (SWIG_arg_fail(4)) SWIG_fail;
4978 }
4979 }
4980 {
4981 if (!wxPyCheckForApp()) SWIG_fail;
4982 PyThreadState* __tstate = wxPyBeginAllowThreads();
4983 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
4984
4985 wxPyEndAllowThreads(__tstate);
4986 if (PyErr_Occurred()) SWIG_fail;
4987 }
4988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
4989 {
4990 if (temp1)
4991 delete arg1;
4992 }
4993 return resultobj;
4994 fail:
4995 {
4996 if (temp1)
4997 delete arg1;
4998 }
4999 return NULL;
5000 }
5001
5002
5003 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5004 PyObject *resultobj;
5005 wxIcon *arg1 = (wxIcon *) 0 ;
5006 PyObject * obj0 = 0 ;
5007 char *kwnames[] = {
5008 (char *) "self", NULL
5009 };
5010
5011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
5012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5013 if (SWIG_arg_fail(1)) SWIG_fail;
5014 {
5015 PyThreadState* __tstate = wxPyBeginAllowThreads();
5016 delete arg1;
5017
5018 wxPyEndAllowThreads(__tstate);
5019 if (PyErr_Occurred()) SWIG_fail;
5020 }
5021 Py_INCREF(Py_None); resultobj = Py_None;
5022 return resultobj;
5023 fail:
5024 return NULL;
5025 }
5026
5027
5028 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5029 PyObject *resultobj;
5030 wxIcon *result;
5031 char *kwnames[] = {
5032 NULL
5033 };
5034
5035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5036 {
5037 if (!wxPyCheckForApp()) SWIG_fail;
5038 PyThreadState* __tstate = wxPyBeginAllowThreads();
5039 result = (wxIcon *)new wxIcon();
5040
5041 wxPyEndAllowThreads(__tstate);
5042 if (PyErr_Occurred()) SWIG_fail;
5043 }
5044 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5045 return resultobj;
5046 fail:
5047 return NULL;
5048 }
5049
5050
5051 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5052 PyObject *resultobj;
5053 wxIconLocation *arg1 = 0 ;
5054 wxIcon *result;
5055 PyObject * obj0 = 0 ;
5056 char *kwnames[] = {
5057 (char *) "loc", NULL
5058 };
5059
5060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5061 {
5062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5063 if (SWIG_arg_fail(1)) SWIG_fail;
5064 if (arg1 == NULL) {
5065 SWIG_null_ref("wxIconLocation");
5066 }
5067 if (SWIG_arg_fail(1)) SWIG_fail;
5068 }
5069 {
5070 if (!wxPyCheckForApp()) SWIG_fail;
5071 PyThreadState* __tstate = wxPyBeginAllowThreads();
5072 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5073
5074 wxPyEndAllowThreads(__tstate);
5075 if (PyErr_Occurred()) SWIG_fail;
5076 }
5077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5078 return resultobj;
5079 fail:
5080 return NULL;
5081 }
5082
5083
5084 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5085 PyObject *resultobj;
5086 wxBitmap *arg1 = 0 ;
5087 wxIcon *result;
5088 PyObject * obj0 = 0 ;
5089 char *kwnames[] = {
5090 (char *) "bmp", NULL
5091 };
5092
5093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5094 {
5095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5096 if (SWIG_arg_fail(1)) SWIG_fail;
5097 if (arg1 == NULL) {
5098 SWIG_null_ref("wxBitmap");
5099 }
5100 if (SWIG_arg_fail(1)) SWIG_fail;
5101 }
5102 {
5103 if (!wxPyCheckForApp()) SWIG_fail;
5104 PyThreadState* __tstate = wxPyBeginAllowThreads();
5105 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5106
5107 wxPyEndAllowThreads(__tstate);
5108 if (PyErr_Occurred()) SWIG_fail;
5109 }
5110 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5111 return resultobj;
5112 fail:
5113 return NULL;
5114 }
5115
5116
5117 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5118 PyObject *resultobj;
5119 PyObject *arg1 = (PyObject *) 0 ;
5120 wxIcon *result;
5121 PyObject * obj0 = 0 ;
5122 char *kwnames[] = {
5123 (char *) "listOfStrings", NULL
5124 };
5125
5126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5127 arg1 = obj0;
5128 {
5129 if (!wxPyCheckForApp()) SWIG_fail;
5130 PyThreadState* __tstate = wxPyBeginAllowThreads();
5131 result = (wxIcon *)new_wxIcon(arg1);
5132
5133 wxPyEndAllowThreads(__tstate);
5134 if (PyErr_Occurred()) SWIG_fail;
5135 }
5136 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5137 return resultobj;
5138 fail:
5139 return NULL;
5140 }
5141
5142
5143 static PyObject *_wrap_Icon_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
5144 PyObject *resultobj;
5145 wxIcon *arg1 = (wxIcon *) 0 ;
5146 wxString *arg2 = 0 ;
5147 wxBitmapType arg3 ;
5148 bool result;
5149 bool temp2 = false ;
5150 PyObject * obj0 = 0 ;
5151 PyObject * obj1 = 0 ;
5152 PyObject * obj2 = 0 ;
5153 char *kwnames[] = {
5154 (char *) "self",(char *) "name",(char *) "type", NULL
5155 };
5156
5157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Icon_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5159 if (SWIG_arg_fail(1)) SWIG_fail;
5160 {
5161 arg2 = wxString_in_helper(obj1);
5162 if (arg2 == NULL) SWIG_fail;
5163 temp2 = true;
5164 }
5165 {
5166 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
5167 if (SWIG_arg_fail(3)) SWIG_fail;
5168 }
5169 {
5170 PyThreadState* __tstate = wxPyBeginAllowThreads();
5171 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
5172
5173 wxPyEndAllowThreads(__tstate);
5174 if (PyErr_Occurred()) SWIG_fail;
5175 }
5176 {
5177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5178 }
5179 {
5180 if (temp2)
5181 delete arg2;
5182 }
5183 return resultobj;
5184 fail:
5185 {
5186 if (temp2)
5187 delete arg2;
5188 }
5189 return NULL;
5190 }
5191
5192
5193 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5194 PyObject *resultobj;
5195 wxIcon *arg1 = (wxIcon *) 0 ;
5196 bool result;
5197 PyObject * obj0 = 0 ;
5198 char *kwnames[] = {
5199 (char *) "self", NULL
5200 };
5201
5202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5204 if (SWIG_arg_fail(1)) SWIG_fail;
5205 {
5206 PyThreadState* __tstate = wxPyBeginAllowThreads();
5207 result = (bool)(arg1)->Ok();
5208
5209 wxPyEndAllowThreads(__tstate);
5210 if (PyErr_Occurred()) SWIG_fail;
5211 }
5212 {
5213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5214 }
5215 return resultobj;
5216 fail:
5217 return NULL;
5218 }
5219
5220
5221 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5222 PyObject *resultobj;
5223 wxIcon *arg1 = (wxIcon *) 0 ;
5224 int result;
5225 PyObject * obj0 = 0 ;
5226 char *kwnames[] = {
5227 (char *) "self", NULL
5228 };
5229
5230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5232 if (SWIG_arg_fail(1)) SWIG_fail;
5233 {
5234 PyThreadState* __tstate = wxPyBeginAllowThreads();
5235 result = (int)(arg1)->GetWidth();
5236
5237 wxPyEndAllowThreads(__tstate);
5238 if (PyErr_Occurred()) SWIG_fail;
5239 }
5240 {
5241 resultobj = SWIG_From_int((int)(result));
5242 }
5243 return resultobj;
5244 fail:
5245 return NULL;
5246 }
5247
5248
5249 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5250 PyObject *resultobj;
5251 wxIcon *arg1 = (wxIcon *) 0 ;
5252 int result;
5253 PyObject * obj0 = 0 ;
5254 char *kwnames[] = {
5255 (char *) "self", NULL
5256 };
5257
5258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5260 if (SWIG_arg_fail(1)) SWIG_fail;
5261 {
5262 PyThreadState* __tstate = wxPyBeginAllowThreads();
5263 result = (int)(arg1)->GetHeight();
5264
5265 wxPyEndAllowThreads(__tstate);
5266 if (PyErr_Occurred()) SWIG_fail;
5267 }
5268 {
5269 resultobj = SWIG_From_int((int)(result));
5270 }
5271 return resultobj;
5272 fail:
5273 return NULL;
5274 }
5275
5276
5277 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5278 PyObject *resultobj;
5279 wxIcon *arg1 = (wxIcon *) 0 ;
5280 int result;
5281 PyObject * obj0 = 0 ;
5282 char *kwnames[] = {
5283 (char *) "self", NULL
5284 };
5285
5286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5288 if (SWIG_arg_fail(1)) SWIG_fail;
5289 {
5290 PyThreadState* __tstate = wxPyBeginAllowThreads();
5291 result = (int)(arg1)->GetDepth();
5292
5293 wxPyEndAllowThreads(__tstate);
5294 if (PyErr_Occurred()) SWIG_fail;
5295 }
5296 {
5297 resultobj = SWIG_From_int((int)(result));
5298 }
5299 return resultobj;
5300 fail:
5301 return NULL;
5302 }
5303
5304
5305 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5306 PyObject *resultobj;
5307 wxIcon *arg1 = (wxIcon *) 0 ;
5308 int arg2 ;
5309 PyObject * obj0 = 0 ;
5310 PyObject * obj1 = 0 ;
5311 char *kwnames[] = {
5312 (char *) "self",(char *) "w", NULL
5313 };
5314
5315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5317 if (SWIG_arg_fail(1)) SWIG_fail;
5318 {
5319 arg2 = (int)(SWIG_As_int(obj1));
5320 if (SWIG_arg_fail(2)) SWIG_fail;
5321 }
5322 {
5323 PyThreadState* __tstate = wxPyBeginAllowThreads();
5324 (arg1)->SetWidth(arg2);
5325
5326 wxPyEndAllowThreads(__tstate);
5327 if (PyErr_Occurred()) SWIG_fail;
5328 }
5329 Py_INCREF(Py_None); resultobj = Py_None;
5330 return resultobj;
5331 fail:
5332 return NULL;
5333 }
5334
5335
5336 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5337 PyObject *resultobj;
5338 wxIcon *arg1 = (wxIcon *) 0 ;
5339 int arg2 ;
5340 PyObject * obj0 = 0 ;
5341 PyObject * obj1 = 0 ;
5342 char *kwnames[] = {
5343 (char *) "self",(char *) "h", NULL
5344 };
5345
5346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5348 if (SWIG_arg_fail(1)) SWIG_fail;
5349 {
5350 arg2 = (int)(SWIG_As_int(obj1));
5351 if (SWIG_arg_fail(2)) SWIG_fail;
5352 }
5353 {
5354 PyThreadState* __tstate = wxPyBeginAllowThreads();
5355 (arg1)->SetHeight(arg2);
5356
5357 wxPyEndAllowThreads(__tstate);
5358 if (PyErr_Occurred()) SWIG_fail;
5359 }
5360 Py_INCREF(Py_None); resultobj = Py_None;
5361 return resultobj;
5362 fail:
5363 return NULL;
5364 }
5365
5366
5367 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5368 PyObject *resultobj;
5369 wxIcon *arg1 = (wxIcon *) 0 ;
5370 int arg2 ;
5371 PyObject * obj0 = 0 ;
5372 PyObject * obj1 = 0 ;
5373 char *kwnames[] = {
5374 (char *) "self",(char *) "d", NULL
5375 };
5376
5377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5379 if (SWIG_arg_fail(1)) SWIG_fail;
5380 {
5381 arg2 = (int)(SWIG_As_int(obj1));
5382 if (SWIG_arg_fail(2)) SWIG_fail;
5383 }
5384 {
5385 PyThreadState* __tstate = wxPyBeginAllowThreads();
5386 (arg1)->SetDepth(arg2);
5387
5388 wxPyEndAllowThreads(__tstate);
5389 if (PyErr_Occurred()) SWIG_fail;
5390 }
5391 Py_INCREF(Py_None); resultobj = Py_None;
5392 return resultobj;
5393 fail:
5394 return NULL;
5395 }
5396
5397
5398 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5399 PyObject *resultobj;
5400 wxIcon *arg1 = (wxIcon *) 0 ;
5401 wxBitmap *arg2 = 0 ;
5402 PyObject * obj0 = 0 ;
5403 PyObject * obj1 = 0 ;
5404 char *kwnames[] = {
5405 (char *) "self",(char *) "bmp", NULL
5406 };
5407
5408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5410 if (SWIG_arg_fail(1)) SWIG_fail;
5411 {
5412 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5413 if (SWIG_arg_fail(2)) SWIG_fail;
5414 if (arg2 == NULL) {
5415 SWIG_null_ref("wxBitmap");
5416 }
5417 if (SWIG_arg_fail(2)) SWIG_fail;
5418 }
5419 {
5420 PyThreadState* __tstate = wxPyBeginAllowThreads();
5421 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5422
5423 wxPyEndAllowThreads(__tstate);
5424 if (PyErr_Occurred()) SWIG_fail;
5425 }
5426 Py_INCREF(Py_None); resultobj = Py_None;
5427 return resultobj;
5428 fail:
5429 return NULL;
5430 }
5431
5432
5433 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5434 PyObject *obj;
5435 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5436 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5437 Py_INCREF(obj);
5438 return Py_BuildValue((char *)"");
5439 }
5440 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5441 PyObject *resultobj;
5442 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5443 int arg2 = (int) 0 ;
5444 wxIconLocation *result;
5445 bool temp1 = false ;
5446 PyObject * obj0 = 0 ;
5447 PyObject * obj1 = 0 ;
5448 char *kwnames[] = {
5449 (char *) "filename",(char *) "num", NULL
5450 };
5451
5452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5453 if (obj0) {
5454 {
5455 arg1 = wxString_in_helper(obj0);
5456 if (arg1 == NULL) SWIG_fail;
5457 temp1 = true;
5458 }
5459 }
5460 if (obj1) {
5461 {
5462 arg2 = (int)(SWIG_As_int(obj1));
5463 if (SWIG_arg_fail(2)) SWIG_fail;
5464 }
5465 }
5466 {
5467 PyThreadState* __tstate = wxPyBeginAllowThreads();
5468 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5469
5470 wxPyEndAllowThreads(__tstate);
5471 if (PyErr_Occurred()) SWIG_fail;
5472 }
5473 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5474 {
5475 if (temp1)
5476 delete arg1;
5477 }
5478 return resultobj;
5479 fail:
5480 {
5481 if (temp1)
5482 delete arg1;
5483 }
5484 return NULL;
5485 }
5486
5487
5488 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5489 PyObject *resultobj;
5490 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5491 PyObject * obj0 = 0 ;
5492 char *kwnames[] = {
5493 (char *) "self", NULL
5494 };
5495
5496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5498 if (SWIG_arg_fail(1)) SWIG_fail;
5499 {
5500 PyThreadState* __tstate = wxPyBeginAllowThreads();
5501 delete arg1;
5502
5503 wxPyEndAllowThreads(__tstate);
5504 if (PyErr_Occurred()) SWIG_fail;
5505 }
5506 Py_INCREF(Py_None); resultobj = Py_None;
5507 return resultobj;
5508 fail:
5509 return NULL;
5510 }
5511
5512
5513 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5514 PyObject *resultobj;
5515 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5516 bool result;
5517 PyObject * obj0 = 0 ;
5518 char *kwnames[] = {
5519 (char *) "self", NULL
5520 };
5521
5522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5524 if (SWIG_arg_fail(1)) SWIG_fail;
5525 {
5526 PyThreadState* __tstate = wxPyBeginAllowThreads();
5527 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5528
5529 wxPyEndAllowThreads(__tstate);
5530 if (PyErr_Occurred()) SWIG_fail;
5531 }
5532 {
5533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5534 }
5535 return resultobj;
5536 fail:
5537 return NULL;
5538 }
5539
5540
5541 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5542 PyObject *resultobj;
5543 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5544 wxString *arg2 = 0 ;
5545 bool temp2 = false ;
5546 PyObject * obj0 = 0 ;
5547 PyObject * obj1 = 0 ;
5548 char *kwnames[] = {
5549 (char *) "self",(char *) "filename", NULL
5550 };
5551
5552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5554 if (SWIG_arg_fail(1)) SWIG_fail;
5555 {
5556 arg2 = wxString_in_helper(obj1);
5557 if (arg2 == NULL) SWIG_fail;
5558 temp2 = true;
5559 }
5560 {
5561 PyThreadState* __tstate = wxPyBeginAllowThreads();
5562 (arg1)->SetFileName((wxString const &)*arg2);
5563
5564 wxPyEndAllowThreads(__tstate);
5565 if (PyErr_Occurred()) SWIG_fail;
5566 }
5567 Py_INCREF(Py_None); resultobj = Py_None;
5568 {
5569 if (temp2)
5570 delete arg2;
5571 }
5572 return resultobj;
5573 fail:
5574 {
5575 if (temp2)
5576 delete arg2;
5577 }
5578 return NULL;
5579 }
5580
5581
5582 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5583 PyObject *resultobj;
5584 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5585 wxString *result;
5586 PyObject * obj0 = 0 ;
5587 char *kwnames[] = {
5588 (char *) "self", NULL
5589 };
5590
5591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5593 if (SWIG_arg_fail(1)) SWIG_fail;
5594 {
5595 PyThreadState* __tstate = wxPyBeginAllowThreads();
5596 {
5597 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5598 result = (wxString *) &_result_ref;
5599 }
5600
5601 wxPyEndAllowThreads(__tstate);
5602 if (PyErr_Occurred()) SWIG_fail;
5603 }
5604 {
5605 #if wxUSE_UNICODE
5606 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5607 #else
5608 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5609 #endif
5610 }
5611 return resultobj;
5612 fail:
5613 return NULL;
5614 }
5615
5616
5617 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5618 PyObject *resultobj;
5619 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5620 int arg2 ;
5621 PyObject * obj0 = 0 ;
5622 PyObject * obj1 = 0 ;
5623 char *kwnames[] = {
5624 (char *) "self",(char *) "num", NULL
5625 };
5626
5627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5629 if (SWIG_arg_fail(1)) SWIG_fail;
5630 {
5631 arg2 = (int)(SWIG_As_int(obj1));
5632 if (SWIG_arg_fail(2)) SWIG_fail;
5633 }
5634 {
5635 PyThreadState* __tstate = wxPyBeginAllowThreads();
5636 wxIconLocation_SetIndex(arg1,arg2);
5637
5638 wxPyEndAllowThreads(__tstate);
5639 if (PyErr_Occurred()) SWIG_fail;
5640 }
5641 Py_INCREF(Py_None); resultobj = Py_None;
5642 return resultobj;
5643 fail:
5644 return NULL;
5645 }
5646
5647
5648 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5649 PyObject *resultobj;
5650 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5651 int result;
5652 PyObject * obj0 = 0 ;
5653 char *kwnames[] = {
5654 (char *) "self", NULL
5655 };
5656
5657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5659 if (SWIG_arg_fail(1)) SWIG_fail;
5660 {
5661 PyThreadState* __tstate = wxPyBeginAllowThreads();
5662 result = (int)wxIconLocation_GetIndex(arg1);
5663
5664 wxPyEndAllowThreads(__tstate);
5665 if (PyErr_Occurred()) SWIG_fail;
5666 }
5667 {
5668 resultobj = SWIG_From_int((int)(result));
5669 }
5670 return resultobj;
5671 fail:
5672 return NULL;
5673 }
5674
5675
5676 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5677 PyObject *obj;
5678 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5679 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5680 Py_INCREF(obj);
5681 return Py_BuildValue((char *)"");
5682 }
5683 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5684 PyObject *resultobj;
5685 wxIconBundle *result;
5686 char *kwnames[] = {
5687 NULL
5688 };
5689
5690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5691 {
5692 PyThreadState* __tstate = wxPyBeginAllowThreads();
5693 result = (wxIconBundle *)new wxIconBundle();
5694
5695 wxPyEndAllowThreads(__tstate);
5696 if (PyErr_Occurred()) SWIG_fail;
5697 }
5698 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5699 return resultobj;
5700 fail:
5701 return NULL;
5702 }
5703
5704
5705 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5706 PyObject *resultobj;
5707 wxString *arg1 = 0 ;
5708 long arg2 ;
5709 wxIconBundle *result;
5710 bool temp1 = false ;
5711 PyObject * obj0 = 0 ;
5712 PyObject * obj1 = 0 ;
5713 char *kwnames[] = {
5714 (char *) "file",(char *) "type", NULL
5715 };
5716
5717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
5718 {
5719 arg1 = wxString_in_helper(obj0);
5720 if (arg1 == NULL) SWIG_fail;
5721 temp1 = true;
5722 }
5723 {
5724 arg2 = (long)(SWIG_As_long(obj1));
5725 if (SWIG_arg_fail(2)) SWIG_fail;
5726 }
5727 {
5728 PyThreadState* __tstate = wxPyBeginAllowThreads();
5729 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
5730
5731 wxPyEndAllowThreads(__tstate);
5732 if (PyErr_Occurred()) SWIG_fail;
5733 }
5734 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5735 {
5736 if (temp1)
5737 delete arg1;
5738 }
5739 return resultobj;
5740 fail:
5741 {
5742 if (temp1)
5743 delete arg1;
5744 }
5745 return NULL;
5746 }
5747
5748
5749 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5750 PyObject *resultobj;
5751 wxIcon *arg1 = 0 ;
5752 wxIconBundle *result;
5753 PyObject * obj0 = 0 ;
5754 char *kwnames[] = {
5755 (char *) "icon", NULL
5756 };
5757
5758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
5759 {
5760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5761 if (SWIG_arg_fail(1)) SWIG_fail;
5762 if (arg1 == NULL) {
5763 SWIG_null_ref("wxIcon");
5764 }
5765 if (SWIG_arg_fail(1)) SWIG_fail;
5766 }
5767 {
5768 PyThreadState* __tstate = wxPyBeginAllowThreads();
5769 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
5770
5771 wxPyEndAllowThreads(__tstate);
5772 if (PyErr_Occurred()) SWIG_fail;
5773 }
5774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5775 return resultobj;
5776 fail:
5777 return NULL;
5778 }
5779
5780
5781 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5782 PyObject *resultobj;
5783 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5784 PyObject * obj0 = 0 ;
5785 char *kwnames[] = {
5786 (char *) "self", NULL
5787 };
5788
5789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
5790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5791 if (SWIG_arg_fail(1)) SWIG_fail;
5792 {
5793 PyThreadState* __tstate = wxPyBeginAllowThreads();
5794 delete arg1;
5795
5796 wxPyEndAllowThreads(__tstate);
5797 if (PyErr_Occurred()) SWIG_fail;
5798 }
5799 Py_INCREF(Py_None); resultobj = Py_None;
5800 return resultobj;
5801 fail:
5802 return NULL;
5803 }
5804
5805
5806 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5807 PyObject *resultobj;
5808 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5809 wxIcon *arg2 = 0 ;
5810 PyObject * obj0 = 0 ;
5811 PyObject * obj1 = 0 ;
5812 char *kwnames[] = {
5813 (char *) "self",(char *) "icon", NULL
5814 };
5815
5816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
5817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5818 if (SWIG_arg_fail(1)) SWIG_fail;
5819 {
5820 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5821 if (SWIG_arg_fail(2)) SWIG_fail;
5822 if (arg2 == NULL) {
5823 SWIG_null_ref("wxIcon");
5824 }
5825 if (SWIG_arg_fail(2)) SWIG_fail;
5826 }
5827 {
5828 PyThreadState* __tstate = wxPyBeginAllowThreads();
5829 (arg1)->AddIcon((wxIcon const &)*arg2);
5830
5831 wxPyEndAllowThreads(__tstate);
5832 if (PyErr_Occurred()) SWIG_fail;
5833 }
5834 Py_INCREF(Py_None); resultobj = Py_None;
5835 return resultobj;
5836 fail:
5837 return NULL;
5838 }
5839
5840
5841 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5842 PyObject *resultobj;
5843 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5844 wxString *arg2 = 0 ;
5845 long arg3 ;
5846 bool temp2 = false ;
5847 PyObject * obj0 = 0 ;
5848 PyObject * obj1 = 0 ;
5849 PyObject * obj2 = 0 ;
5850 char *kwnames[] = {
5851 (char *) "self",(char *) "file",(char *) "type", NULL
5852 };
5853
5854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5856 if (SWIG_arg_fail(1)) SWIG_fail;
5857 {
5858 arg2 = wxString_in_helper(obj1);
5859 if (arg2 == NULL) SWIG_fail;
5860 temp2 = true;
5861 }
5862 {
5863 arg3 = (long)(SWIG_As_long(obj2));
5864 if (SWIG_arg_fail(3)) SWIG_fail;
5865 }
5866 {
5867 PyThreadState* __tstate = wxPyBeginAllowThreads();
5868 (arg1)->AddIcon((wxString const &)*arg2,arg3);
5869
5870 wxPyEndAllowThreads(__tstate);
5871 if (PyErr_Occurred()) SWIG_fail;
5872 }
5873 Py_INCREF(Py_None); resultobj = Py_None;
5874 {
5875 if (temp2)
5876 delete arg2;
5877 }
5878 return resultobj;
5879 fail:
5880 {
5881 if (temp2)
5882 delete arg2;
5883 }
5884 return NULL;
5885 }
5886
5887
5888 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5889 PyObject *resultobj;
5890 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5891 wxSize *arg2 = 0 ;
5892 wxIcon *result;
5893 wxSize temp2 ;
5894 PyObject * obj0 = 0 ;
5895 PyObject * obj1 = 0 ;
5896 char *kwnames[] = {
5897 (char *) "self",(char *) "size", NULL
5898 };
5899
5900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
5901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5902 if (SWIG_arg_fail(1)) SWIG_fail;
5903 {
5904 arg2 = &temp2;
5905 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5906 }
5907 {
5908 PyThreadState* __tstate = wxPyBeginAllowThreads();
5909 {
5910 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
5911 result = (wxIcon *) &_result_ref;
5912 }
5913
5914 wxPyEndAllowThreads(__tstate);
5915 if (PyErr_Occurred()) SWIG_fail;
5916 }
5917 {
5918 wxIcon* resultptr = new wxIcon(*result);
5919 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
5920 }
5921 return resultobj;
5922 fail:
5923 return NULL;
5924 }
5925
5926
5927 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
5928 PyObject *obj;
5929 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5930 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
5931 Py_INCREF(obj);
5932 return Py_BuildValue((char *)"");
5933 }
5934 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5935 PyObject *resultobj;
5936 wxString *arg1 = 0 ;
5937 long arg2 ;
5938 int arg3 = (int) 0 ;
5939 int arg4 = (int) 0 ;
5940 wxCursor *result;
5941 bool temp1 = false ;
5942 PyObject * obj0 = 0 ;
5943 PyObject * obj1 = 0 ;
5944 PyObject * obj2 = 0 ;
5945 PyObject * obj3 = 0 ;
5946 char *kwnames[] = {
5947 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
5948 };
5949
5950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5951 {
5952 arg1 = wxString_in_helper(obj0);
5953 if (arg1 == NULL) SWIG_fail;
5954 temp1 = true;
5955 }
5956 {
5957 arg2 = (long)(SWIG_As_long(obj1));
5958 if (SWIG_arg_fail(2)) SWIG_fail;
5959 }
5960 if (obj2) {
5961 {
5962 arg3 = (int)(SWIG_As_int(obj2));
5963 if (SWIG_arg_fail(3)) SWIG_fail;
5964 }
5965 }
5966 if (obj3) {
5967 {
5968 arg4 = (int)(SWIG_As_int(obj3));
5969 if (SWIG_arg_fail(4)) SWIG_fail;
5970 }
5971 }
5972 {
5973 if (!wxPyCheckForApp()) SWIG_fail;
5974 PyThreadState* __tstate = wxPyBeginAllowThreads();
5975 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
5976
5977 wxPyEndAllowThreads(__tstate);
5978 if (PyErr_Occurred()) SWIG_fail;
5979 }
5980 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
5981 {
5982 if (temp1)
5983 delete arg1;
5984 }
5985 return resultobj;
5986 fail:
5987 {
5988 if (temp1)
5989 delete arg1;
5990 }
5991 return NULL;
5992 }
5993
5994
5995 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5996 PyObject *resultobj;
5997 wxCursor *arg1 = (wxCursor *) 0 ;
5998 PyObject * obj0 = 0 ;
5999 char *kwnames[] = {
6000 (char *) "self", NULL
6001 };
6002
6003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
6004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6005 if (SWIG_arg_fail(1)) SWIG_fail;
6006 {
6007 PyThreadState* __tstate = wxPyBeginAllowThreads();
6008 delete arg1;
6009
6010 wxPyEndAllowThreads(__tstate);
6011 if (PyErr_Occurred()) SWIG_fail;
6012 }
6013 Py_INCREF(Py_None); resultobj = Py_None;
6014 return resultobj;
6015 fail:
6016 return NULL;
6017 }
6018
6019
6020 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6021 PyObject *resultobj;
6022 int arg1 ;
6023 wxCursor *result;
6024 PyObject * obj0 = 0 ;
6025 char *kwnames[] = {
6026 (char *) "id", NULL
6027 };
6028
6029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
6030 {
6031 arg1 = (int)(SWIG_As_int(obj0));
6032 if (SWIG_arg_fail(1)) SWIG_fail;
6033 }
6034 {
6035 if (!wxPyCheckForApp()) SWIG_fail;
6036 PyThreadState* __tstate = wxPyBeginAllowThreads();
6037 result = (wxCursor *)new wxCursor(arg1);
6038
6039 wxPyEndAllowThreads(__tstate);
6040 if (PyErr_Occurred()) SWIG_fail;
6041 }
6042 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6043 return resultobj;
6044 fail:
6045 return NULL;
6046 }
6047
6048
6049 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6050 PyObject *resultobj;
6051 wxImage *arg1 = 0 ;
6052 wxCursor *result;
6053 PyObject * obj0 = 0 ;
6054 char *kwnames[] = {
6055 (char *) "image", NULL
6056 };
6057
6058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6059 {
6060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6061 if (SWIG_arg_fail(1)) SWIG_fail;
6062 if (arg1 == NULL) {
6063 SWIG_null_ref("wxImage");
6064 }
6065 if (SWIG_arg_fail(1)) SWIG_fail;
6066 }
6067 {
6068 if (!wxPyCheckForApp()) SWIG_fail;
6069 PyThreadState* __tstate = wxPyBeginAllowThreads();
6070 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6071
6072 wxPyEndAllowThreads(__tstate);
6073 if (PyErr_Occurred()) SWIG_fail;
6074 }
6075 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6076 return resultobj;
6077 fail:
6078 return NULL;
6079 }
6080
6081
6082 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6083 PyObject *resultobj;
6084 wxCursor *arg1 = (wxCursor *) 0 ;
6085 bool result;
6086 PyObject * obj0 = 0 ;
6087 char *kwnames[] = {
6088 (char *) "self", NULL
6089 };
6090
6091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6093 if (SWIG_arg_fail(1)) SWIG_fail;
6094 {
6095 PyThreadState* __tstate = wxPyBeginAllowThreads();
6096 result = (bool)(arg1)->Ok();
6097
6098 wxPyEndAllowThreads(__tstate);
6099 if (PyErr_Occurred()) SWIG_fail;
6100 }
6101 {
6102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6103 }
6104 return resultobj;
6105 fail:
6106 return NULL;
6107 }
6108
6109
6110 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6111 PyObject *obj;
6112 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6113 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6114 Py_INCREF(obj);
6115 return Py_BuildValue((char *)"");
6116 }
6117 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6118 PyObject *resultobj;
6119 int arg1 = (int) 0 ;
6120 int arg2 = (int) 0 ;
6121 int arg3 = (int) 0 ;
6122 int arg4 = (int) 0 ;
6123 wxRegion *result;
6124 PyObject * obj0 = 0 ;
6125 PyObject * obj1 = 0 ;
6126 PyObject * obj2 = 0 ;
6127 PyObject * obj3 = 0 ;
6128 char *kwnames[] = {
6129 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6130 };
6131
6132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6133 if (obj0) {
6134 {
6135 arg1 = (int)(SWIG_As_int(obj0));
6136 if (SWIG_arg_fail(1)) SWIG_fail;
6137 }
6138 }
6139 if (obj1) {
6140 {
6141 arg2 = (int)(SWIG_As_int(obj1));
6142 if (SWIG_arg_fail(2)) SWIG_fail;
6143 }
6144 }
6145 if (obj2) {
6146 {
6147 arg3 = (int)(SWIG_As_int(obj2));
6148 if (SWIG_arg_fail(3)) SWIG_fail;
6149 }
6150 }
6151 if (obj3) {
6152 {
6153 arg4 = (int)(SWIG_As_int(obj3));
6154 if (SWIG_arg_fail(4)) SWIG_fail;
6155 }
6156 }
6157 {
6158 if (!wxPyCheckForApp()) SWIG_fail;
6159 PyThreadState* __tstate = wxPyBeginAllowThreads();
6160 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6161
6162 wxPyEndAllowThreads(__tstate);
6163 if (PyErr_Occurred()) SWIG_fail;
6164 }
6165 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6166 return resultobj;
6167 fail:
6168 return NULL;
6169 }
6170
6171
6172 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6173 PyObject *resultobj;
6174 wxBitmap *arg1 = 0 ;
6175 wxRegion *result;
6176 PyObject * obj0 = 0 ;
6177 char *kwnames[] = {
6178 (char *) "bmp", NULL
6179 };
6180
6181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6182 {
6183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6184 if (SWIG_arg_fail(1)) SWIG_fail;
6185 if (arg1 == NULL) {
6186 SWIG_null_ref("wxBitmap");
6187 }
6188 if (SWIG_arg_fail(1)) SWIG_fail;
6189 }
6190 {
6191 if (!wxPyCheckForApp()) SWIG_fail;
6192 PyThreadState* __tstate = wxPyBeginAllowThreads();
6193 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6194
6195 wxPyEndAllowThreads(__tstate);
6196 if (PyErr_Occurred()) SWIG_fail;
6197 }
6198 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6199 return resultobj;
6200 fail:
6201 return NULL;
6202 }
6203
6204
6205 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6206 PyObject *resultobj;
6207 wxBitmap *arg1 = 0 ;
6208 wxColour *arg2 = 0 ;
6209 int arg3 = (int) 0 ;
6210 wxRegion *result;
6211 wxColour temp2 ;
6212 PyObject * obj0 = 0 ;
6213 PyObject * obj1 = 0 ;
6214 PyObject * obj2 = 0 ;
6215 char *kwnames[] = {
6216 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6217 };
6218
6219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6220 {
6221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6222 if (SWIG_arg_fail(1)) SWIG_fail;
6223 if (arg1 == NULL) {
6224 SWIG_null_ref("wxBitmap");
6225 }
6226 if (SWIG_arg_fail(1)) SWIG_fail;
6227 }
6228 {
6229 arg2 = &temp2;
6230 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6231 }
6232 if (obj2) {
6233 {
6234 arg3 = (int)(SWIG_As_int(obj2));
6235 if (SWIG_arg_fail(3)) SWIG_fail;
6236 }
6237 }
6238 {
6239 if (!wxPyCheckForApp()) SWIG_fail;
6240 PyThreadState* __tstate = wxPyBeginAllowThreads();
6241 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6242
6243 wxPyEndAllowThreads(__tstate);
6244 if (PyErr_Occurred()) SWIG_fail;
6245 }
6246 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6247 return resultobj;
6248 fail:
6249 return NULL;
6250 }
6251
6252
6253 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6254 PyObject *resultobj;
6255 int arg1 ;
6256 wxPoint *arg2 = (wxPoint *) 0 ;
6257 int arg3 = (int) wxWINDING_RULE ;
6258 wxRegion *result;
6259 PyObject * obj0 = 0 ;
6260 PyObject * obj1 = 0 ;
6261 char *kwnames[] = {
6262 (char *) "points",(char *) "fillStyle", NULL
6263 };
6264
6265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6266 {
6267 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6268 if (arg2 == NULL) SWIG_fail;
6269 }
6270 if (obj1) {
6271 {
6272 arg3 = (int)(SWIG_As_int(obj1));
6273 if (SWIG_arg_fail(3)) SWIG_fail;
6274 }
6275 }
6276 {
6277 if (!wxPyCheckForApp()) SWIG_fail;
6278 PyThreadState* __tstate = wxPyBeginAllowThreads();
6279 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6280
6281 wxPyEndAllowThreads(__tstate);
6282 if (PyErr_Occurred()) SWIG_fail;
6283 }
6284 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6285 {
6286 if (arg2) delete [] arg2;
6287 }
6288 return resultobj;
6289 fail:
6290 {
6291 if (arg2) delete [] arg2;
6292 }
6293 return NULL;
6294 }
6295
6296
6297 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6298 PyObject *resultobj;
6299 wxRegion *arg1 = (wxRegion *) 0 ;
6300 PyObject * obj0 = 0 ;
6301 char *kwnames[] = {
6302 (char *) "self", NULL
6303 };
6304
6305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6307 if (SWIG_arg_fail(1)) SWIG_fail;
6308 {
6309 PyThreadState* __tstate = wxPyBeginAllowThreads();
6310 delete arg1;
6311
6312 wxPyEndAllowThreads(__tstate);
6313 if (PyErr_Occurred()) SWIG_fail;
6314 }
6315 Py_INCREF(Py_None); resultobj = Py_None;
6316 return resultobj;
6317 fail:
6318 return NULL;
6319 }
6320
6321
6322 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6323 PyObject *resultobj;
6324 wxRegion *arg1 = (wxRegion *) 0 ;
6325 PyObject * obj0 = 0 ;
6326 char *kwnames[] = {
6327 (char *) "self", NULL
6328 };
6329
6330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6332 if (SWIG_arg_fail(1)) SWIG_fail;
6333 {
6334 PyThreadState* __tstate = wxPyBeginAllowThreads();
6335 (arg1)->Clear();
6336
6337 wxPyEndAllowThreads(__tstate);
6338 if (PyErr_Occurred()) SWIG_fail;
6339 }
6340 Py_INCREF(Py_None); resultobj = Py_None;
6341 return resultobj;
6342 fail:
6343 return NULL;
6344 }
6345
6346
6347 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6348 PyObject *resultobj;
6349 wxRegion *arg1 = (wxRegion *) 0 ;
6350 int arg2 ;
6351 int arg3 ;
6352 bool result;
6353 PyObject * obj0 = 0 ;
6354 PyObject * obj1 = 0 ;
6355 PyObject * obj2 = 0 ;
6356 char *kwnames[] = {
6357 (char *) "self",(char *) "x",(char *) "y", NULL
6358 };
6359
6360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6362 if (SWIG_arg_fail(1)) SWIG_fail;
6363 {
6364 arg2 = (int)(SWIG_As_int(obj1));
6365 if (SWIG_arg_fail(2)) SWIG_fail;
6366 }
6367 {
6368 arg3 = (int)(SWIG_As_int(obj2));
6369 if (SWIG_arg_fail(3)) SWIG_fail;
6370 }
6371 {
6372 PyThreadState* __tstate = wxPyBeginAllowThreads();
6373 result = (bool)(arg1)->Offset(arg2,arg3);
6374
6375 wxPyEndAllowThreads(__tstate);
6376 if (PyErr_Occurred()) SWIG_fail;
6377 }
6378 {
6379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6380 }
6381 return resultobj;
6382 fail:
6383 return NULL;
6384 }
6385
6386
6387 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6388 PyObject *resultobj;
6389 wxRegion *arg1 = (wxRegion *) 0 ;
6390 int arg2 ;
6391 int arg3 ;
6392 wxRegionContain result;
6393 PyObject * obj0 = 0 ;
6394 PyObject * obj1 = 0 ;
6395 PyObject * obj2 = 0 ;
6396 char *kwnames[] = {
6397 (char *) "self",(char *) "x",(char *) "y", NULL
6398 };
6399
6400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6402 if (SWIG_arg_fail(1)) SWIG_fail;
6403 {
6404 arg2 = (int)(SWIG_As_int(obj1));
6405 if (SWIG_arg_fail(2)) SWIG_fail;
6406 }
6407 {
6408 arg3 = (int)(SWIG_As_int(obj2));
6409 if (SWIG_arg_fail(3)) SWIG_fail;
6410 }
6411 {
6412 PyThreadState* __tstate = wxPyBeginAllowThreads();
6413 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6414
6415 wxPyEndAllowThreads(__tstate);
6416 if (PyErr_Occurred()) SWIG_fail;
6417 }
6418 resultobj = SWIG_From_int((result));
6419 return resultobj;
6420 fail:
6421 return NULL;
6422 }
6423
6424
6425 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6426 PyObject *resultobj;
6427 wxRegion *arg1 = (wxRegion *) 0 ;
6428 wxPoint *arg2 = 0 ;
6429 wxRegionContain result;
6430 wxPoint temp2 ;
6431 PyObject * obj0 = 0 ;
6432 PyObject * obj1 = 0 ;
6433 char *kwnames[] = {
6434 (char *) "self",(char *) "pt", NULL
6435 };
6436
6437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6439 if (SWIG_arg_fail(1)) SWIG_fail;
6440 {
6441 arg2 = &temp2;
6442 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6443 }
6444 {
6445 PyThreadState* __tstate = wxPyBeginAllowThreads();
6446 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
6447
6448 wxPyEndAllowThreads(__tstate);
6449 if (PyErr_Occurred()) SWIG_fail;
6450 }
6451 resultobj = SWIG_From_int((result));
6452 return resultobj;
6453 fail:
6454 return NULL;
6455 }
6456
6457
6458 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
6459 PyObject *resultobj;
6460 wxRegion *arg1 = (wxRegion *) 0 ;
6461 wxRect *arg2 = 0 ;
6462 wxRegionContain result;
6463 wxRect temp2 ;
6464 PyObject * obj0 = 0 ;
6465 PyObject * obj1 = 0 ;
6466 char *kwnames[] = {
6467 (char *) "self",(char *) "rect", NULL
6468 };
6469
6470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
6471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6472 if (SWIG_arg_fail(1)) SWIG_fail;
6473 {
6474 arg2 = &temp2;
6475 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6476 }
6477 {
6478 PyThreadState* __tstate = wxPyBeginAllowThreads();
6479 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
6480
6481 wxPyEndAllowThreads(__tstate);
6482 if (PyErr_Occurred()) SWIG_fail;
6483 }
6484 resultobj = SWIG_From_int((result));
6485 return resultobj;
6486 fail:
6487 return NULL;
6488 }
6489
6490
6491 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
6492 PyObject *resultobj;
6493 wxRegion *arg1 = (wxRegion *) 0 ;
6494 int arg2 ;
6495 int arg3 ;
6496 int arg4 ;
6497 int arg5 ;
6498 wxRegionContain result;
6499 PyObject * obj0 = 0 ;
6500 PyObject * obj1 = 0 ;
6501 PyObject * obj2 = 0 ;
6502 PyObject * obj3 = 0 ;
6503 PyObject * obj4 = 0 ;
6504 char *kwnames[] = {
6505 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
6506 };
6507
6508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6510 if (SWIG_arg_fail(1)) SWIG_fail;
6511 {
6512 arg2 = (int)(SWIG_As_int(obj1));
6513 if (SWIG_arg_fail(2)) SWIG_fail;
6514 }
6515 {
6516 arg3 = (int)(SWIG_As_int(obj2));
6517 if (SWIG_arg_fail(3)) SWIG_fail;
6518 }
6519 {
6520 arg4 = (int)(SWIG_As_int(obj3));
6521 if (SWIG_arg_fail(4)) SWIG_fail;
6522 }
6523 {
6524 arg5 = (int)(SWIG_As_int(obj4));
6525 if (SWIG_arg_fail(5)) SWIG_fail;
6526 }
6527 {
6528 PyThreadState* __tstate = wxPyBeginAllowThreads();
6529 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
6530
6531 wxPyEndAllowThreads(__tstate);
6532 if (PyErr_Occurred()) SWIG_fail;
6533 }
6534 resultobj = SWIG_From_int((result));
6535 return resultobj;
6536 fail:
6537 return NULL;
6538 }
6539
6540
6541 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
6542 PyObject *resultobj;
6543 wxRegion *arg1 = (wxRegion *) 0 ;
6544 wxRect result;
6545 PyObject * obj0 = 0 ;
6546 char *kwnames[] = {
6547 (char *) "self", NULL
6548 };
6549
6550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
6551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6552 if (SWIG_arg_fail(1)) SWIG_fail;
6553 {
6554 PyThreadState* __tstate = wxPyBeginAllowThreads();
6555 result = (arg1)->GetBox();
6556
6557 wxPyEndAllowThreads(__tstate);
6558 if (PyErr_Occurred()) SWIG_fail;
6559 }
6560 {
6561 wxRect * resultptr;
6562 resultptr = new wxRect((wxRect &)(result));
6563 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6564 }
6565 return resultobj;
6566 fail:
6567 return NULL;
6568 }
6569
6570
6571 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
6572 PyObject *resultobj;
6573 wxRegion *arg1 = (wxRegion *) 0 ;
6574 int arg2 ;
6575 int arg3 ;
6576 int arg4 ;
6577 int arg5 ;
6578 bool result;
6579 PyObject * obj0 = 0 ;
6580 PyObject * obj1 = 0 ;
6581 PyObject * obj2 = 0 ;
6582 PyObject * obj3 = 0 ;
6583 PyObject * obj4 = 0 ;
6584 char *kwnames[] = {
6585 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6586 };
6587
6588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6590 if (SWIG_arg_fail(1)) SWIG_fail;
6591 {
6592 arg2 = (int)(SWIG_As_int(obj1));
6593 if (SWIG_arg_fail(2)) SWIG_fail;
6594 }
6595 {
6596 arg3 = (int)(SWIG_As_int(obj2));
6597 if (SWIG_arg_fail(3)) SWIG_fail;
6598 }
6599 {
6600 arg4 = (int)(SWIG_As_int(obj3));
6601 if (SWIG_arg_fail(4)) SWIG_fail;
6602 }
6603 {
6604 arg5 = (int)(SWIG_As_int(obj4));
6605 if (SWIG_arg_fail(5)) SWIG_fail;
6606 }
6607 {
6608 PyThreadState* __tstate = wxPyBeginAllowThreads();
6609 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
6610
6611 wxPyEndAllowThreads(__tstate);
6612 if (PyErr_Occurred()) SWIG_fail;
6613 }
6614 {
6615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6616 }
6617 return resultobj;
6618 fail:
6619 return NULL;
6620 }
6621
6622
6623 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6624 PyObject *resultobj;
6625 wxRegion *arg1 = (wxRegion *) 0 ;
6626 wxRect *arg2 = 0 ;
6627 bool result;
6628 wxRect temp2 ;
6629 PyObject * obj0 = 0 ;
6630 PyObject * obj1 = 0 ;
6631 char *kwnames[] = {
6632 (char *) "self",(char *) "rect", NULL
6633 };
6634
6635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6637 if (SWIG_arg_fail(1)) SWIG_fail;
6638 {
6639 arg2 = &temp2;
6640 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6641 }
6642 {
6643 PyThreadState* __tstate = wxPyBeginAllowThreads();
6644 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
6645
6646 wxPyEndAllowThreads(__tstate);
6647 if (PyErr_Occurred()) SWIG_fail;
6648 }
6649 {
6650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6651 }
6652 return resultobj;
6653 fail:
6654 return NULL;
6655 }
6656
6657
6658 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6659 PyObject *resultobj;
6660 wxRegion *arg1 = (wxRegion *) 0 ;
6661 wxRegion *arg2 = 0 ;
6662 bool result;
6663 PyObject * obj0 = 0 ;
6664 PyObject * obj1 = 0 ;
6665 char *kwnames[] = {
6666 (char *) "self",(char *) "region", NULL
6667 };
6668
6669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
6670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6671 if (SWIG_arg_fail(1)) SWIG_fail;
6672 {
6673 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6674 if (SWIG_arg_fail(2)) SWIG_fail;
6675 if (arg2 == NULL) {
6676 SWIG_null_ref("wxRegion");
6677 }
6678 if (SWIG_arg_fail(2)) SWIG_fail;
6679 }
6680 {
6681 PyThreadState* __tstate = wxPyBeginAllowThreads();
6682 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
6683
6684 wxPyEndAllowThreads(__tstate);
6685 if (PyErr_Occurred()) SWIG_fail;
6686 }
6687 {
6688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6689 }
6690 return resultobj;
6691 fail:
6692 return NULL;
6693 }
6694
6695
6696 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
6697 PyObject *resultobj;
6698 wxRegion *arg1 = (wxRegion *) 0 ;
6699 bool result;
6700 PyObject * obj0 = 0 ;
6701 char *kwnames[] = {
6702 (char *) "self", NULL
6703 };
6704
6705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
6706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6707 if (SWIG_arg_fail(1)) SWIG_fail;
6708 {
6709 PyThreadState* __tstate = wxPyBeginAllowThreads();
6710 result = (bool)(arg1)->IsEmpty();
6711
6712 wxPyEndAllowThreads(__tstate);
6713 if (PyErr_Occurred()) SWIG_fail;
6714 }
6715 {
6716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6717 }
6718 return resultobj;
6719 fail:
6720 return NULL;
6721 }
6722
6723
6724 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6725 PyObject *resultobj;
6726 wxRegion *arg1 = (wxRegion *) 0 ;
6727 int arg2 ;
6728 int arg3 ;
6729 int arg4 ;
6730 int arg5 ;
6731 bool result;
6732 PyObject * obj0 = 0 ;
6733 PyObject * obj1 = 0 ;
6734 PyObject * obj2 = 0 ;
6735 PyObject * obj3 = 0 ;
6736 PyObject * obj4 = 0 ;
6737 char *kwnames[] = {
6738 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6739 };
6740
6741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6743 if (SWIG_arg_fail(1)) SWIG_fail;
6744 {
6745 arg2 = (int)(SWIG_As_int(obj1));
6746 if (SWIG_arg_fail(2)) SWIG_fail;
6747 }
6748 {
6749 arg3 = (int)(SWIG_As_int(obj2));
6750 if (SWIG_arg_fail(3)) SWIG_fail;
6751 }
6752 {
6753 arg4 = (int)(SWIG_As_int(obj3));
6754 if (SWIG_arg_fail(4)) SWIG_fail;
6755 }
6756 {
6757 arg5 = (int)(SWIG_As_int(obj4));
6758 if (SWIG_arg_fail(5)) SWIG_fail;
6759 }
6760 {
6761 PyThreadState* __tstate = wxPyBeginAllowThreads();
6762 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
6763
6764 wxPyEndAllowThreads(__tstate);
6765 if (PyErr_Occurred()) SWIG_fail;
6766 }
6767 {
6768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6769 }
6770 return resultobj;
6771 fail:
6772 return NULL;
6773 }
6774
6775
6776 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
6777 PyObject *resultobj;
6778 wxRegion *arg1 = (wxRegion *) 0 ;
6779 wxRect *arg2 = 0 ;
6780 bool result;
6781 wxRect temp2 ;
6782 PyObject * obj0 = 0 ;
6783 PyObject * obj1 = 0 ;
6784 char *kwnames[] = {
6785 (char *) "self",(char *) "rect", NULL
6786 };
6787
6788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
6789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6790 if (SWIG_arg_fail(1)) SWIG_fail;
6791 {
6792 arg2 = &temp2;
6793 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6794 }
6795 {
6796 PyThreadState* __tstate = wxPyBeginAllowThreads();
6797 result = (bool)(arg1)->Union((wxRect const &)*arg2);
6798
6799 wxPyEndAllowThreads(__tstate);
6800 if (PyErr_Occurred()) SWIG_fail;
6801 }
6802 {
6803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6804 }
6805 return resultobj;
6806 fail:
6807 return NULL;
6808 }
6809
6810
6811 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6812 PyObject *resultobj;
6813 wxRegion *arg1 = (wxRegion *) 0 ;
6814 wxRegion *arg2 = 0 ;
6815 bool result;
6816 PyObject * obj0 = 0 ;
6817 PyObject * obj1 = 0 ;
6818 char *kwnames[] = {
6819 (char *) "self",(char *) "region", NULL
6820 };
6821
6822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
6823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6824 if (SWIG_arg_fail(1)) SWIG_fail;
6825 {
6826 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6827 if (SWIG_arg_fail(2)) SWIG_fail;
6828 if (arg2 == NULL) {
6829 SWIG_null_ref("wxRegion");
6830 }
6831 if (SWIG_arg_fail(2)) SWIG_fail;
6832 }
6833 {
6834 PyThreadState* __tstate = wxPyBeginAllowThreads();
6835 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
6836
6837 wxPyEndAllowThreads(__tstate);
6838 if (PyErr_Occurred()) SWIG_fail;
6839 }
6840 {
6841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6842 }
6843 return resultobj;
6844 fail:
6845 return NULL;
6846 }
6847
6848
6849 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
6850 PyObject *resultobj;
6851 wxRegion *arg1 = (wxRegion *) 0 ;
6852 int arg2 ;
6853 int arg3 ;
6854 int arg4 ;
6855 int arg5 ;
6856 bool result;
6857 PyObject * obj0 = 0 ;
6858 PyObject * obj1 = 0 ;
6859 PyObject * obj2 = 0 ;
6860 PyObject * obj3 = 0 ;
6861 PyObject * obj4 = 0 ;
6862 char *kwnames[] = {
6863 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6864 };
6865
6866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6868 if (SWIG_arg_fail(1)) SWIG_fail;
6869 {
6870 arg2 = (int)(SWIG_As_int(obj1));
6871 if (SWIG_arg_fail(2)) SWIG_fail;
6872 }
6873 {
6874 arg3 = (int)(SWIG_As_int(obj2));
6875 if (SWIG_arg_fail(3)) SWIG_fail;
6876 }
6877 {
6878 arg4 = (int)(SWIG_As_int(obj3));
6879 if (SWIG_arg_fail(4)) SWIG_fail;
6880 }
6881 {
6882 arg5 = (int)(SWIG_As_int(obj4));
6883 if (SWIG_arg_fail(5)) SWIG_fail;
6884 }
6885 {
6886 PyThreadState* __tstate = wxPyBeginAllowThreads();
6887 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
6888
6889 wxPyEndAllowThreads(__tstate);
6890 if (PyErr_Occurred()) SWIG_fail;
6891 }
6892 {
6893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6894 }
6895 return resultobj;
6896 fail:
6897 return NULL;
6898 }
6899
6900
6901 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
6902 PyObject *resultobj;
6903 wxRegion *arg1 = (wxRegion *) 0 ;
6904 wxRect *arg2 = 0 ;
6905 bool result;
6906 wxRect temp2 ;
6907 PyObject * obj0 = 0 ;
6908 PyObject * obj1 = 0 ;
6909 char *kwnames[] = {
6910 (char *) "self",(char *) "rect", NULL
6911 };
6912
6913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
6914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6915 if (SWIG_arg_fail(1)) SWIG_fail;
6916 {
6917 arg2 = &temp2;
6918 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6919 }
6920 {
6921 PyThreadState* __tstate = wxPyBeginAllowThreads();
6922 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
6923
6924 wxPyEndAllowThreads(__tstate);
6925 if (PyErr_Occurred()) SWIG_fail;
6926 }
6927 {
6928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6929 }
6930 return resultobj;
6931 fail:
6932 return NULL;
6933 }
6934
6935
6936 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6937 PyObject *resultobj;
6938 wxRegion *arg1 = (wxRegion *) 0 ;
6939 wxRegion *arg2 = 0 ;
6940 bool result;
6941 PyObject * obj0 = 0 ;
6942 PyObject * obj1 = 0 ;
6943 char *kwnames[] = {
6944 (char *) "self",(char *) "region", NULL
6945 };
6946
6947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
6948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6949 if (SWIG_arg_fail(1)) SWIG_fail;
6950 {
6951 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6952 if (SWIG_arg_fail(2)) SWIG_fail;
6953 if (arg2 == NULL) {
6954 SWIG_null_ref("wxRegion");
6955 }
6956 if (SWIG_arg_fail(2)) SWIG_fail;
6957 }
6958 {
6959 PyThreadState* __tstate = wxPyBeginAllowThreads();
6960 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
6961
6962 wxPyEndAllowThreads(__tstate);
6963 if (PyErr_Occurred()) SWIG_fail;
6964 }
6965 {
6966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6967 }
6968 return resultobj;
6969 fail:
6970 return NULL;
6971 }
6972
6973
6974 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
6975 PyObject *resultobj;
6976 wxRegion *arg1 = (wxRegion *) 0 ;
6977 int arg2 ;
6978 int arg3 ;
6979 int arg4 ;
6980 int arg5 ;
6981 bool result;
6982 PyObject * obj0 = 0 ;
6983 PyObject * obj1 = 0 ;
6984 PyObject * obj2 = 0 ;
6985 PyObject * obj3 = 0 ;
6986 PyObject * obj4 = 0 ;
6987 char *kwnames[] = {
6988 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6989 };
6990
6991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6993 if (SWIG_arg_fail(1)) SWIG_fail;
6994 {
6995 arg2 = (int)(SWIG_As_int(obj1));
6996 if (SWIG_arg_fail(2)) SWIG_fail;
6997 }
6998 {
6999 arg3 = (int)(SWIG_As_int(obj2));
7000 if (SWIG_arg_fail(3)) SWIG_fail;
7001 }
7002 {
7003 arg4 = (int)(SWIG_As_int(obj3));
7004 if (SWIG_arg_fail(4)) SWIG_fail;
7005 }
7006 {
7007 arg5 = (int)(SWIG_As_int(obj4));
7008 if (SWIG_arg_fail(5)) SWIG_fail;
7009 }
7010 {
7011 PyThreadState* __tstate = wxPyBeginAllowThreads();
7012 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
7013
7014 wxPyEndAllowThreads(__tstate);
7015 if (PyErr_Occurred()) SWIG_fail;
7016 }
7017 {
7018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7019 }
7020 return resultobj;
7021 fail:
7022 return NULL;
7023 }
7024
7025
7026 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
7027 PyObject *resultobj;
7028 wxRegion *arg1 = (wxRegion *) 0 ;
7029 wxRect *arg2 = 0 ;
7030 bool result;
7031 wxRect temp2 ;
7032 PyObject * obj0 = 0 ;
7033 PyObject * obj1 = 0 ;
7034 char *kwnames[] = {
7035 (char *) "self",(char *) "rect", NULL
7036 };
7037
7038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7040 if (SWIG_arg_fail(1)) SWIG_fail;
7041 {
7042 arg2 = &temp2;
7043 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7044 }
7045 {
7046 PyThreadState* __tstate = wxPyBeginAllowThreads();
7047 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7048
7049 wxPyEndAllowThreads(__tstate);
7050 if (PyErr_Occurred()) SWIG_fail;
7051 }
7052 {
7053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7054 }
7055 return resultobj;
7056 fail:
7057 return NULL;
7058 }
7059
7060
7061 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7062 PyObject *resultobj;
7063 wxRegion *arg1 = (wxRegion *) 0 ;
7064 wxRegion *arg2 = 0 ;
7065 bool result;
7066 PyObject * obj0 = 0 ;
7067 PyObject * obj1 = 0 ;
7068 char *kwnames[] = {
7069 (char *) "self",(char *) "region", NULL
7070 };
7071
7072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7074 if (SWIG_arg_fail(1)) SWIG_fail;
7075 {
7076 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7077 if (SWIG_arg_fail(2)) SWIG_fail;
7078 if (arg2 == NULL) {
7079 SWIG_null_ref("wxRegion");
7080 }
7081 if (SWIG_arg_fail(2)) SWIG_fail;
7082 }
7083 {
7084 PyThreadState* __tstate = wxPyBeginAllowThreads();
7085 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7086
7087 wxPyEndAllowThreads(__tstate);
7088 if (PyErr_Occurred()) SWIG_fail;
7089 }
7090 {
7091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7092 }
7093 return resultobj;
7094 fail:
7095 return NULL;
7096 }
7097
7098
7099 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7100 PyObject *resultobj;
7101 wxRegion *arg1 = (wxRegion *) 0 ;
7102 SwigValueWrapper<wxBitmap > result;
7103 PyObject * obj0 = 0 ;
7104 char *kwnames[] = {
7105 (char *) "self", NULL
7106 };
7107
7108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7110 if (SWIG_arg_fail(1)) SWIG_fail;
7111 {
7112 PyThreadState* __tstate = wxPyBeginAllowThreads();
7113 result = (arg1)->ConvertToBitmap();
7114
7115 wxPyEndAllowThreads(__tstate);
7116 if (PyErr_Occurred()) SWIG_fail;
7117 }
7118 {
7119 wxBitmap * resultptr;
7120 resultptr = new wxBitmap((wxBitmap &)(result));
7121 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7122 }
7123 return resultobj;
7124 fail:
7125 return NULL;
7126 }
7127
7128
7129 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7130 PyObject *resultobj;
7131 wxRegion *arg1 = (wxRegion *) 0 ;
7132 wxBitmap *arg2 = 0 ;
7133 bool result;
7134 PyObject * obj0 = 0 ;
7135 PyObject * obj1 = 0 ;
7136 char *kwnames[] = {
7137 (char *) "self",(char *) "bmp", NULL
7138 };
7139
7140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7142 if (SWIG_arg_fail(1)) SWIG_fail;
7143 {
7144 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7145 if (SWIG_arg_fail(2)) SWIG_fail;
7146 if (arg2 == NULL) {
7147 SWIG_null_ref("wxBitmap");
7148 }
7149 if (SWIG_arg_fail(2)) SWIG_fail;
7150 }
7151 {
7152 PyThreadState* __tstate = wxPyBeginAllowThreads();
7153 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7154
7155 wxPyEndAllowThreads(__tstate);
7156 if (PyErr_Occurred()) SWIG_fail;
7157 }
7158 {
7159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7160 }
7161 return resultobj;
7162 fail:
7163 return NULL;
7164 }
7165
7166
7167 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7168 PyObject *resultobj;
7169 wxRegion *arg1 = (wxRegion *) 0 ;
7170 wxBitmap *arg2 = 0 ;
7171 wxColour *arg3 = 0 ;
7172 int arg4 = (int) 0 ;
7173 bool result;
7174 wxColour temp3 ;
7175 PyObject * obj0 = 0 ;
7176 PyObject * obj1 = 0 ;
7177 PyObject * obj2 = 0 ;
7178 PyObject * obj3 = 0 ;
7179 char *kwnames[] = {
7180 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7181 };
7182
7183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7185 if (SWIG_arg_fail(1)) SWIG_fail;
7186 {
7187 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7188 if (SWIG_arg_fail(2)) SWIG_fail;
7189 if (arg2 == NULL) {
7190 SWIG_null_ref("wxBitmap");
7191 }
7192 if (SWIG_arg_fail(2)) SWIG_fail;
7193 }
7194 {
7195 arg3 = &temp3;
7196 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7197 }
7198 if (obj3) {
7199 {
7200 arg4 = (int)(SWIG_As_int(obj3));
7201 if (SWIG_arg_fail(4)) SWIG_fail;
7202 }
7203 }
7204 {
7205 PyThreadState* __tstate = wxPyBeginAllowThreads();
7206 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7207
7208 wxPyEndAllowThreads(__tstate);
7209 if (PyErr_Occurred()) SWIG_fail;
7210 }
7211 {
7212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7213 }
7214 return resultobj;
7215 fail:
7216 return NULL;
7217 }
7218
7219
7220 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7221 PyObject *obj;
7222 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7223 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7224 Py_INCREF(obj);
7225 return Py_BuildValue((char *)"");
7226 }
7227 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7228 PyObject *resultobj;
7229 wxRegion *arg1 = 0 ;
7230 wxRegionIterator *result;
7231 PyObject * obj0 = 0 ;
7232 char *kwnames[] = {
7233 (char *) "region", NULL
7234 };
7235
7236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7237 {
7238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7239 if (SWIG_arg_fail(1)) SWIG_fail;
7240 if (arg1 == NULL) {
7241 SWIG_null_ref("wxRegion");
7242 }
7243 if (SWIG_arg_fail(1)) SWIG_fail;
7244 }
7245 {
7246 if (!wxPyCheckForApp()) SWIG_fail;
7247 PyThreadState* __tstate = wxPyBeginAllowThreads();
7248 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7249
7250 wxPyEndAllowThreads(__tstate);
7251 if (PyErr_Occurred()) SWIG_fail;
7252 }
7253 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7254 return resultobj;
7255 fail:
7256 return NULL;
7257 }
7258
7259
7260 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7261 PyObject *resultobj;
7262 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7263 PyObject * obj0 = 0 ;
7264 char *kwnames[] = {
7265 (char *) "self", NULL
7266 };
7267
7268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7270 if (SWIG_arg_fail(1)) SWIG_fail;
7271 {
7272 PyThreadState* __tstate = wxPyBeginAllowThreads();
7273 delete arg1;
7274
7275 wxPyEndAllowThreads(__tstate);
7276 if (PyErr_Occurred()) SWIG_fail;
7277 }
7278 Py_INCREF(Py_None); resultobj = Py_None;
7279 return resultobj;
7280 fail:
7281 return NULL;
7282 }
7283
7284
7285 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7286 PyObject *resultobj;
7287 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7288 int result;
7289 PyObject * obj0 = 0 ;
7290 char *kwnames[] = {
7291 (char *) "self", NULL
7292 };
7293
7294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7296 if (SWIG_arg_fail(1)) SWIG_fail;
7297 {
7298 PyThreadState* __tstate = wxPyBeginAllowThreads();
7299 result = (int)(arg1)->GetX();
7300
7301 wxPyEndAllowThreads(__tstate);
7302 if (PyErr_Occurred()) SWIG_fail;
7303 }
7304 {
7305 resultobj = SWIG_From_int((int)(result));
7306 }
7307 return resultobj;
7308 fail:
7309 return NULL;
7310 }
7311
7312
7313 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7314 PyObject *resultobj;
7315 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7316 int result;
7317 PyObject * obj0 = 0 ;
7318 char *kwnames[] = {
7319 (char *) "self", NULL
7320 };
7321
7322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7324 if (SWIG_arg_fail(1)) SWIG_fail;
7325 {
7326 PyThreadState* __tstate = wxPyBeginAllowThreads();
7327 result = (int)(arg1)->GetY();
7328
7329 wxPyEndAllowThreads(__tstate);
7330 if (PyErr_Occurred()) SWIG_fail;
7331 }
7332 {
7333 resultobj = SWIG_From_int((int)(result));
7334 }
7335 return resultobj;
7336 fail:
7337 return NULL;
7338 }
7339
7340
7341 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7342 PyObject *resultobj;
7343 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7344 int result;
7345 PyObject * obj0 = 0 ;
7346 char *kwnames[] = {
7347 (char *) "self", NULL
7348 };
7349
7350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7352 if (SWIG_arg_fail(1)) SWIG_fail;
7353 {
7354 PyThreadState* __tstate = wxPyBeginAllowThreads();
7355 result = (int)(arg1)->GetW();
7356
7357 wxPyEndAllowThreads(__tstate);
7358 if (PyErr_Occurred()) SWIG_fail;
7359 }
7360 {
7361 resultobj = SWIG_From_int((int)(result));
7362 }
7363 return resultobj;
7364 fail:
7365 return NULL;
7366 }
7367
7368
7369 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7370 PyObject *resultobj;
7371 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7372 int result;
7373 PyObject * obj0 = 0 ;
7374 char *kwnames[] = {
7375 (char *) "self", NULL
7376 };
7377
7378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7380 if (SWIG_arg_fail(1)) SWIG_fail;
7381 {
7382 PyThreadState* __tstate = wxPyBeginAllowThreads();
7383 result = (int)(arg1)->GetWidth();
7384
7385 wxPyEndAllowThreads(__tstate);
7386 if (PyErr_Occurred()) SWIG_fail;
7387 }
7388 {
7389 resultobj = SWIG_From_int((int)(result));
7390 }
7391 return resultobj;
7392 fail:
7393 return NULL;
7394 }
7395
7396
7397 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7398 PyObject *resultobj;
7399 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7400 int result;
7401 PyObject * obj0 = 0 ;
7402 char *kwnames[] = {
7403 (char *) "self", NULL
7404 };
7405
7406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7408 if (SWIG_arg_fail(1)) SWIG_fail;
7409 {
7410 PyThreadState* __tstate = wxPyBeginAllowThreads();
7411 result = (int)(arg1)->GetH();
7412
7413 wxPyEndAllowThreads(__tstate);
7414 if (PyErr_Occurred()) SWIG_fail;
7415 }
7416 {
7417 resultobj = SWIG_From_int((int)(result));
7418 }
7419 return resultobj;
7420 fail:
7421 return NULL;
7422 }
7423
7424
7425 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7426 PyObject *resultobj;
7427 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7428 int result;
7429 PyObject * obj0 = 0 ;
7430 char *kwnames[] = {
7431 (char *) "self", NULL
7432 };
7433
7434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7436 if (SWIG_arg_fail(1)) SWIG_fail;
7437 {
7438 PyThreadState* __tstate = wxPyBeginAllowThreads();
7439 result = (int)(arg1)->GetHeight();
7440
7441 wxPyEndAllowThreads(__tstate);
7442 if (PyErr_Occurred()) SWIG_fail;
7443 }
7444 {
7445 resultobj = SWIG_From_int((int)(result));
7446 }
7447 return resultobj;
7448 fail:
7449 return NULL;
7450 }
7451
7452
7453 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
7454 PyObject *resultobj;
7455 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7456 wxRect result;
7457 PyObject * obj0 = 0 ;
7458 char *kwnames[] = {
7459 (char *) "self", NULL
7460 };
7461
7462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
7463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7464 if (SWIG_arg_fail(1)) SWIG_fail;
7465 {
7466 PyThreadState* __tstate = wxPyBeginAllowThreads();
7467 result = (arg1)->GetRect();
7468
7469 wxPyEndAllowThreads(__tstate);
7470 if (PyErr_Occurred()) SWIG_fail;
7471 }
7472 {
7473 wxRect * resultptr;
7474 resultptr = new wxRect((wxRect &)(result));
7475 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7476 }
7477 return resultobj;
7478 fail:
7479 return NULL;
7480 }
7481
7482
7483 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
7484 PyObject *resultobj;
7485 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7486 bool result;
7487 PyObject * obj0 = 0 ;
7488 char *kwnames[] = {
7489 (char *) "self", NULL
7490 };
7491
7492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
7493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7494 if (SWIG_arg_fail(1)) SWIG_fail;
7495 {
7496 PyThreadState* __tstate = wxPyBeginAllowThreads();
7497 result = (bool)(arg1)->HaveRects();
7498
7499 wxPyEndAllowThreads(__tstate);
7500 if (PyErr_Occurred()) SWIG_fail;
7501 }
7502 {
7503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7504 }
7505 return resultobj;
7506 fail:
7507 return NULL;
7508 }
7509
7510
7511 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
7512 PyObject *resultobj;
7513 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7514 PyObject * obj0 = 0 ;
7515 char *kwnames[] = {
7516 (char *) "self", NULL
7517 };
7518
7519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
7520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7521 if (SWIG_arg_fail(1)) SWIG_fail;
7522 {
7523 PyThreadState* __tstate = wxPyBeginAllowThreads();
7524 (arg1)->Reset();
7525
7526 wxPyEndAllowThreads(__tstate);
7527 if (PyErr_Occurred()) SWIG_fail;
7528 }
7529 Py_INCREF(Py_None); resultobj = Py_None;
7530 return resultobj;
7531 fail:
7532 return NULL;
7533 }
7534
7535
7536 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
7537 PyObject *resultobj;
7538 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7539 PyObject * obj0 = 0 ;
7540 char *kwnames[] = {
7541 (char *) "self", NULL
7542 };
7543
7544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
7545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7546 if (SWIG_arg_fail(1)) SWIG_fail;
7547 {
7548 PyThreadState* __tstate = wxPyBeginAllowThreads();
7549 wxRegionIterator_Next(arg1);
7550
7551 wxPyEndAllowThreads(__tstate);
7552 if (PyErr_Occurred()) SWIG_fail;
7553 }
7554 Py_INCREF(Py_None); resultobj = Py_None;
7555 return resultobj;
7556 fail:
7557 return NULL;
7558 }
7559
7560
7561 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
7562 PyObject *resultobj;
7563 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7564 bool result;
7565 PyObject * obj0 = 0 ;
7566 char *kwnames[] = {
7567 (char *) "self", NULL
7568 };
7569
7570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
7571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7572 if (SWIG_arg_fail(1)) SWIG_fail;
7573 {
7574 PyThreadState* __tstate = wxPyBeginAllowThreads();
7575 result = (bool)wxRegionIterator___nonzero__(arg1);
7576
7577 wxPyEndAllowThreads(__tstate);
7578 if (PyErr_Occurred()) SWIG_fail;
7579 }
7580 {
7581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7582 }
7583 return resultobj;
7584 fail:
7585 return NULL;
7586 }
7587
7588
7589 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
7590 PyObject *obj;
7591 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7592 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
7593 Py_INCREF(obj);
7594 return Py_BuildValue((char *)"");
7595 }
7596 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7597 PyObject *resultobj;
7598 wxNativeFontInfo *result;
7599 char *kwnames[] = {
7600 NULL
7601 };
7602
7603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
7604 {
7605 PyThreadState* __tstate = wxPyBeginAllowThreads();
7606 result = (wxNativeFontInfo *)new wxNativeFontInfo();
7607
7608 wxPyEndAllowThreads(__tstate);
7609 if (PyErr_Occurred()) SWIG_fail;
7610 }
7611 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
7612 return resultobj;
7613 fail:
7614 return NULL;
7615 }
7616
7617
7618 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7619 PyObject *resultobj;
7620 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7621 PyObject * obj0 = 0 ;
7622 char *kwnames[] = {
7623 (char *) "self", NULL
7624 };
7625
7626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
7627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7628 if (SWIG_arg_fail(1)) SWIG_fail;
7629 {
7630 PyThreadState* __tstate = wxPyBeginAllowThreads();
7631 delete arg1;
7632
7633 wxPyEndAllowThreads(__tstate);
7634 if (PyErr_Occurred()) SWIG_fail;
7635 }
7636 Py_INCREF(Py_None); resultobj = Py_None;
7637 return resultobj;
7638 fail:
7639 return NULL;
7640 }
7641
7642
7643 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
7644 PyObject *resultobj;
7645 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7646 PyObject * obj0 = 0 ;
7647 char *kwnames[] = {
7648 (char *) "self", NULL
7649 };
7650
7651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
7652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7653 if (SWIG_arg_fail(1)) SWIG_fail;
7654 {
7655 PyThreadState* __tstate = wxPyBeginAllowThreads();
7656 (arg1)->Init();
7657
7658 wxPyEndAllowThreads(__tstate);
7659 if (PyErr_Occurred()) SWIG_fail;
7660 }
7661 Py_INCREF(Py_None); resultobj = Py_None;
7662 return resultobj;
7663 fail:
7664 return NULL;
7665 }
7666
7667
7668 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
7669 PyObject *resultobj;
7670 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7671 wxFont *arg2 = 0 ;
7672 PyObject * obj0 = 0 ;
7673 PyObject * obj1 = 0 ;
7674 char *kwnames[] = {
7675 (char *) "self",(char *) "font", NULL
7676 };
7677
7678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
7679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7680 if (SWIG_arg_fail(1)) SWIG_fail;
7681 {
7682 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
7683 if (SWIG_arg_fail(2)) SWIG_fail;
7684 if (arg2 == NULL) {
7685 SWIG_null_ref("wxFont");
7686 }
7687 if (SWIG_arg_fail(2)) SWIG_fail;
7688 }
7689 {
7690 PyThreadState* __tstate = wxPyBeginAllowThreads();
7691 (arg1)->InitFromFont((wxFont const &)*arg2);
7692
7693 wxPyEndAllowThreads(__tstate);
7694 if (PyErr_Occurred()) SWIG_fail;
7695 }
7696 Py_INCREF(Py_None); resultobj = Py_None;
7697 return resultobj;
7698 fail:
7699 return NULL;
7700 }
7701
7702
7703 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7704 PyObject *resultobj;
7705 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7706 int result;
7707 PyObject * obj0 = 0 ;
7708 char *kwnames[] = {
7709 (char *) "self", NULL
7710 };
7711
7712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
7713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7714 if (SWIG_arg_fail(1)) SWIG_fail;
7715 {
7716 PyThreadState* __tstate = wxPyBeginAllowThreads();
7717 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
7718
7719 wxPyEndAllowThreads(__tstate);
7720 if (PyErr_Occurred()) SWIG_fail;
7721 }
7722 {
7723 resultobj = SWIG_From_int((int)(result));
7724 }
7725 return resultobj;
7726 fail:
7727 return NULL;
7728 }
7729
7730
7731 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7732 PyObject *resultobj;
7733 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7734 wxFontStyle result;
7735 PyObject * obj0 = 0 ;
7736 char *kwnames[] = {
7737 (char *) "self", NULL
7738 };
7739
7740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
7741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7742 if (SWIG_arg_fail(1)) SWIG_fail;
7743 {
7744 PyThreadState* __tstate = wxPyBeginAllowThreads();
7745 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
7746
7747 wxPyEndAllowThreads(__tstate);
7748 if (PyErr_Occurred()) SWIG_fail;
7749 }
7750 resultobj = SWIG_From_int((result));
7751 return resultobj;
7752 fail:
7753 return NULL;
7754 }
7755
7756
7757 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7758 PyObject *resultobj;
7759 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7760 wxFontWeight result;
7761 PyObject * obj0 = 0 ;
7762 char *kwnames[] = {
7763 (char *) "self", NULL
7764 };
7765
7766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
7767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7768 if (SWIG_arg_fail(1)) SWIG_fail;
7769 {
7770 PyThreadState* __tstate = wxPyBeginAllowThreads();
7771 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
7772
7773 wxPyEndAllowThreads(__tstate);
7774 if (PyErr_Occurred()) SWIG_fail;
7775 }
7776 resultobj = SWIG_From_int((result));
7777 return resultobj;
7778 fail:
7779 return NULL;
7780 }
7781
7782
7783 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7784 PyObject *resultobj;
7785 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7786 bool result;
7787 PyObject * obj0 = 0 ;
7788 char *kwnames[] = {
7789 (char *) "self", NULL
7790 };
7791
7792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
7793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7794 if (SWIG_arg_fail(1)) SWIG_fail;
7795 {
7796 PyThreadState* __tstate = wxPyBeginAllowThreads();
7797 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
7798
7799 wxPyEndAllowThreads(__tstate);
7800 if (PyErr_Occurred()) SWIG_fail;
7801 }
7802 {
7803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7804 }
7805 return resultobj;
7806 fail:
7807 return NULL;
7808 }
7809
7810
7811 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7812 PyObject *resultobj;
7813 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7814 wxString result;
7815 PyObject * obj0 = 0 ;
7816 char *kwnames[] = {
7817 (char *) "self", NULL
7818 };
7819
7820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
7821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7822 if (SWIG_arg_fail(1)) SWIG_fail;
7823 {
7824 PyThreadState* __tstate = wxPyBeginAllowThreads();
7825 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
7826
7827 wxPyEndAllowThreads(__tstate);
7828 if (PyErr_Occurred()) SWIG_fail;
7829 }
7830 {
7831 #if wxUSE_UNICODE
7832 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7833 #else
7834 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7835 #endif
7836 }
7837 return resultobj;
7838 fail:
7839 return NULL;
7840 }
7841
7842
7843 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
7844 PyObject *resultobj;
7845 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7846 wxFontFamily result;
7847 PyObject * obj0 = 0 ;
7848 char *kwnames[] = {
7849 (char *) "self", NULL
7850 };
7851
7852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
7853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7854 if (SWIG_arg_fail(1)) SWIG_fail;
7855 {
7856 PyThreadState* __tstate = wxPyBeginAllowThreads();
7857 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
7858
7859 wxPyEndAllowThreads(__tstate);
7860 if (PyErr_Occurred()) SWIG_fail;
7861 }
7862 resultobj = SWIG_From_int((result));
7863 return resultobj;
7864 fail:
7865 return NULL;
7866 }
7867
7868
7869 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
7870 PyObject *resultobj;
7871 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7872 wxFontEncoding result;
7873 PyObject * obj0 = 0 ;
7874 char *kwnames[] = {
7875 (char *) "self", NULL
7876 };
7877
7878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
7879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7880 if (SWIG_arg_fail(1)) SWIG_fail;
7881 {
7882 PyThreadState* __tstate = wxPyBeginAllowThreads();
7883 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
7884
7885 wxPyEndAllowThreads(__tstate);
7886 if (PyErr_Occurred()) SWIG_fail;
7887 }
7888 resultobj = SWIG_From_int((result));
7889 return resultobj;
7890 fail:
7891 return NULL;
7892 }
7893
7894
7895 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7896 PyObject *resultobj;
7897 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7898 int arg2 ;
7899 PyObject * obj0 = 0 ;
7900 PyObject * obj1 = 0 ;
7901 char *kwnames[] = {
7902 (char *) "self",(char *) "pointsize", NULL
7903 };
7904
7905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
7906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7907 if (SWIG_arg_fail(1)) SWIG_fail;
7908 {
7909 arg2 = (int)(SWIG_As_int(obj1));
7910 if (SWIG_arg_fail(2)) SWIG_fail;
7911 }
7912 {
7913 PyThreadState* __tstate = wxPyBeginAllowThreads();
7914 (arg1)->SetPointSize(arg2);
7915
7916 wxPyEndAllowThreads(__tstate);
7917 if (PyErr_Occurred()) SWIG_fail;
7918 }
7919 Py_INCREF(Py_None); resultobj = Py_None;
7920 return resultobj;
7921 fail:
7922 return NULL;
7923 }
7924
7925
7926 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7927 PyObject *resultobj;
7928 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7929 wxFontStyle arg2 ;
7930 PyObject * obj0 = 0 ;
7931 PyObject * obj1 = 0 ;
7932 char *kwnames[] = {
7933 (char *) "self",(char *) "style", NULL
7934 };
7935
7936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
7937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7938 if (SWIG_arg_fail(1)) SWIG_fail;
7939 {
7940 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
7941 if (SWIG_arg_fail(2)) SWIG_fail;
7942 }
7943 {
7944 PyThreadState* __tstate = wxPyBeginAllowThreads();
7945 (arg1)->SetStyle((wxFontStyle )arg2);
7946
7947 wxPyEndAllowThreads(__tstate);
7948 if (PyErr_Occurred()) SWIG_fail;
7949 }
7950 Py_INCREF(Py_None); resultobj = Py_None;
7951 return resultobj;
7952 fail:
7953 return NULL;
7954 }
7955
7956
7957 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7958 PyObject *resultobj;
7959 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7960 wxFontWeight arg2 ;
7961 PyObject * obj0 = 0 ;
7962 PyObject * obj1 = 0 ;
7963 char *kwnames[] = {
7964 (char *) "self",(char *) "weight", NULL
7965 };
7966
7967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
7968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7969 if (SWIG_arg_fail(1)) SWIG_fail;
7970 {
7971 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
7972 if (SWIG_arg_fail(2)) SWIG_fail;
7973 }
7974 {
7975 PyThreadState* __tstate = wxPyBeginAllowThreads();
7976 (arg1)->SetWeight((wxFontWeight )arg2);
7977
7978 wxPyEndAllowThreads(__tstate);
7979 if (PyErr_Occurred()) SWIG_fail;
7980 }
7981 Py_INCREF(Py_None); resultobj = Py_None;
7982 return resultobj;
7983 fail:
7984 return NULL;
7985 }
7986
7987
7988 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7989 PyObject *resultobj;
7990 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7991 bool arg2 ;
7992 PyObject * obj0 = 0 ;
7993 PyObject * obj1 = 0 ;
7994 char *kwnames[] = {
7995 (char *) "self",(char *) "underlined", NULL
7996 };
7997
7998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
7999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8000 if (SWIG_arg_fail(1)) SWIG_fail;
8001 {
8002 arg2 = (bool)(SWIG_As_bool(obj1));
8003 if (SWIG_arg_fail(2)) SWIG_fail;
8004 }
8005 {
8006 PyThreadState* __tstate = wxPyBeginAllowThreads();
8007 (arg1)->SetUnderlined(arg2);
8008
8009 wxPyEndAllowThreads(__tstate);
8010 if (PyErr_Occurred()) SWIG_fail;
8011 }
8012 Py_INCREF(Py_None); resultobj = Py_None;
8013 return resultobj;
8014 fail:
8015 return NULL;
8016 }
8017
8018
8019 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8020 PyObject *resultobj;
8021 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8022 wxString arg2 ;
8023 PyObject * obj0 = 0 ;
8024 PyObject * obj1 = 0 ;
8025 char *kwnames[] = {
8026 (char *) "self",(char *) "facename", NULL
8027 };
8028
8029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
8030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8031 if (SWIG_arg_fail(1)) SWIG_fail;
8032 {
8033 wxString* sptr = wxString_in_helper(obj1);
8034 if (sptr == NULL) SWIG_fail;
8035 arg2 = *sptr;
8036 delete sptr;
8037 }
8038 {
8039 PyThreadState* __tstate = wxPyBeginAllowThreads();
8040 (arg1)->SetFaceName(arg2);
8041
8042 wxPyEndAllowThreads(__tstate);
8043 if (PyErr_Occurred()) SWIG_fail;
8044 }
8045 Py_INCREF(Py_None); resultobj = Py_None;
8046 return resultobj;
8047 fail:
8048 return NULL;
8049 }
8050
8051
8052 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8053 PyObject *resultobj;
8054 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8055 wxFontFamily arg2 ;
8056 PyObject * obj0 = 0 ;
8057 PyObject * obj1 = 0 ;
8058 char *kwnames[] = {
8059 (char *) "self",(char *) "family", NULL
8060 };
8061
8062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8064 if (SWIG_arg_fail(1)) SWIG_fail;
8065 {
8066 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8067 if (SWIG_arg_fail(2)) SWIG_fail;
8068 }
8069 {
8070 PyThreadState* __tstate = wxPyBeginAllowThreads();
8071 (arg1)->SetFamily((wxFontFamily )arg2);
8072
8073 wxPyEndAllowThreads(__tstate);
8074 if (PyErr_Occurred()) SWIG_fail;
8075 }
8076 Py_INCREF(Py_None); resultobj = Py_None;
8077 return resultobj;
8078 fail:
8079 return NULL;
8080 }
8081
8082
8083 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8084 PyObject *resultobj;
8085 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8086 wxFontEncoding arg2 ;
8087 PyObject * obj0 = 0 ;
8088 PyObject * obj1 = 0 ;
8089 char *kwnames[] = {
8090 (char *) "self",(char *) "encoding", NULL
8091 };
8092
8093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8095 if (SWIG_arg_fail(1)) SWIG_fail;
8096 {
8097 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8098 if (SWIG_arg_fail(2)) SWIG_fail;
8099 }
8100 {
8101 PyThreadState* __tstate = wxPyBeginAllowThreads();
8102 (arg1)->SetEncoding((wxFontEncoding )arg2);
8103
8104 wxPyEndAllowThreads(__tstate);
8105 if (PyErr_Occurred()) SWIG_fail;
8106 }
8107 Py_INCREF(Py_None); resultobj = Py_None;
8108 return resultobj;
8109 fail:
8110 return NULL;
8111 }
8112
8113
8114 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8115 PyObject *resultobj;
8116 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8117 wxString *arg2 = 0 ;
8118 bool result;
8119 bool temp2 = false ;
8120 PyObject * obj0 = 0 ;
8121 PyObject * obj1 = 0 ;
8122 char *kwnames[] = {
8123 (char *) "self",(char *) "s", NULL
8124 };
8125
8126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8128 if (SWIG_arg_fail(1)) SWIG_fail;
8129 {
8130 arg2 = wxString_in_helper(obj1);
8131 if (arg2 == NULL) SWIG_fail;
8132 temp2 = true;
8133 }
8134 {
8135 PyThreadState* __tstate = wxPyBeginAllowThreads();
8136 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8137
8138 wxPyEndAllowThreads(__tstate);
8139 if (PyErr_Occurred()) SWIG_fail;
8140 }
8141 {
8142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8143 }
8144 {
8145 if (temp2)
8146 delete arg2;
8147 }
8148 return resultobj;
8149 fail:
8150 {
8151 if (temp2)
8152 delete arg2;
8153 }
8154 return NULL;
8155 }
8156
8157
8158 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8159 PyObject *resultobj;
8160 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8161 wxString result;
8162 PyObject * obj0 = 0 ;
8163 char *kwnames[] = {
8164 (char *) "self", NULL
8165 };
8166
8167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8169 if (SWIG_arg_fail(1)) SWIG_fail;
8170 {
8171 PyThreadState* __tstate = wxPyBeginAllowThreads();
8172 result = ((wxNativeFontInfo const *)arg1)->ToString();
8173
8174 wxPyEndAllowThreads(__tstate);
8175 if (PyErr_Occurred()) SWIG_fail;
8176 }
8177 {
8178 #if wxUSE_UNICODE
8179 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8180 #else
8181 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8182 #endif
8183 }
8184 return resultobj;
8185 fail:
8186 return NULL;
8187 }
8188
8189
8190 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8191 PyObject *resultobj;
8192 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8193 wxString result;
8194 PyObject * obj0 = 0 ;
8195 char *kwnames[] = {
8196 (char *) "self", NULL
8197 };
8198
8199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8201 if (SWIG_arg_fail(1)) SWIG_fail;
8202 {
8203 PyThreadState* __tstate = wxPyBeginAllowThreads();
8204 result = wxNativeFontInfo___str__(arg1);
8205
8206 wxPyEndAllowThreads(__tstate);
8207 if (PyErr_Occurred()) SWIG_fail;
8208 }
8209 {
8210 #if wxUSE_UNICODE
8211 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8212 #else
8213 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8214 #endif
8215 }
8216 return resultobj;
8217 fail:
8218 return NULL;
8219 }
8220
8221
8222 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8223 PyObject *resultobj;
8224 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8225 wxString *arg2 = 0 ;
8226 bool result;
8227 bool temp2 = false ;
8228 PyObject * obj0 = 0 ;
8229 PyObject * obj1 = 0 ;
8230 char *kwnames[] = {
8231 (char *) "self",(char *) "s", NULL
8232 };
8233
8234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8236 if (SWIG_arg_fail(1)) SWIG_fail;
8237 {
8238 arg2 = wxString_in_helper(obj1);
8239 if (arg2 == NULL) SWIG_fail;
8240 temp2 = true;
8241 }
8242 {
8243 PyThreadState* __tstate = wxPyBeginAllowThreads();
8244 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8245
8246 wxPyEndAllowThreads(__tstate);
8247 if (PyErr_Occurred()) SWIG_fail;
8248 }
8249 {
8250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8251 }
8252 {
8253 if (temp2)
8254 delete arg2;
8255 }
8256 return resultobj;
8257 fail:
8258 {
8259 if (temp2)
8260 delete arg2;
8261 }
8262 return NULL;
8263 }
8264
8265
8266 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8267 PyObject *resultobj;
8268 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8269 wxString result;
8270 PyObject * obj0 = 0 ;
8271 char *kwnames[] = {
8272 (char *) "self", NULL
8273 };
8274
8275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8277 if (SWIG_arg_fail(1)) SWIG_fail;
8278 {
8279 PyThreadState* __tstate = wxPyBeginAllowThreads();
8280 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8281
8282 wxPyEndAllowThreads(__tstate);
8283 if (PyErr_Occurred()) SWIG_fail;
8284 }
8285 {
8286 #if wxUSE_UNICODE
8287 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8288 #else
8289 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8290 #endif
8291 }
8292 return resultobj;
8293 fail:
8294 return NULL;
8295 }
8296
8297
8298 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8299 PyObject *obj;
8300 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8301 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8302 Py_INCREF(obj);
8303 return Py_BuildValue((char *)"");
8304 }
8305 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8306 PyObject *resultobj;
8307 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8308 wxString *arg2 = (wxString *) 0 ;
8309 bool temp2 = false ;
8310 PyObject * obj0 = 0 ;
8311 PyObject * obj1 = 0 ;
8312 char *kwnames[] = {
8313 (char *) "self",(char *) "facename", NULL
8314 };
8315
8316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8318 if (SWIG_arg_fail(1)) SWIG_fail;
8319 {
8320 arg2 = wxString_in_helper(obj1);
8321 if (arg2 == NULL) SWIG_fail;
8322 temp2 = true;
8323 }
8324 if (arg1) (arg1)->facename = *arg2;
8325
8326 Py_INCREF(Py_None); resultobj = Py_None;
8327 {
8328 if (temp2)
8329 delete arg2;
8330 }
8331 return resultobj;
8332 fail:
8333 {
8334 if (temp2)
8335 delete arg2;
8336 }
8337 return NULL;
8338 }
8339
8340
8341 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8342 PyObject *resultobj;
8343 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8344 wxString *result;
8345 PyObject * obj0 = 0 ;
8346 char *kwnames[] = {
8347 (char *) "self", NULL
8348 };
8349
8350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
8351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8352 if (SWIG_arg_fail(1)) SWIG_fail;
8353 result = (wxString *)& ((arg1)->facename);
8354
8355 {
8356 #if wxUSE_UNICODE
8357 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8358 #else
8359 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8360 #endif
8361 }
8362 return resultobj;
8363 fail:
8364 return NULL;
8365 }
8366
8367
8368 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8369 PyObject *resultobj;
8370 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8371 wxFontEncoding arg2 ;
8372 PyObject * obj0 = 0 ;
8373 PyObject * obj1 = 0 ;
8374 char *kwnames[] = {
8375 (char *) "self",(char *) "encoding", NULL
8376 };
8377
8378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
8379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8380 if (SWIG_arg_fail(1)) SWIG_fail;
8381 {
8382 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8383 if (SWIG_arg_fail(2)) SWIG_fail;
8384 }
8385 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
8386
8387 Py_INCREF(Py_None); resultobj = Py_None;
8388 return resultobj;
8389 fail:
8390 return NULL;
8391 }
8392
8393
8394 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
8395 PyObject *resultobj;
8396 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8397 wxFontEncoding result;
8398 PyObject * obj0 = 0 ;
8399 char *kwnames[] = {
8400 (char *) "self", NULL
8401 };
8402
8403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
8404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8405 if (SWIG_arg_fail(1)) SWIG_fail;
8406 result = (wxFontEncoding) ((arg1)->encoding);
8407
8408 resultobj = SWIG_From_int((result));
8409 return resultobj;
8410 fail:
8411 return NULL;
8412 }
8413
8414
8415 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8416 PyObject *resultobj;
8417 wxNativeEncodingInfo *result;
8418 char *kwnames[] = {
8419 NULL
8420 };
8421
8422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
8423 {
8424 PyThreadState* __tstate = wxPyBeginAllowThreads();
8425 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
8426
8427 wxPyEndAllowThreads(__tstate);
8428 if (PyErr_Occurred()) SWIG_fail;
8429 }
8430 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
8431 return resultobj;
8432 fail:
8433 return NULL;
8434 }
8435
8436
8437 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8438 PyObject *resultobj;
8439 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8440 PyObject * obj0 = 0 ;
8441 char *kwnames[] = {
8442 (char *) "self", NULL
8443 };
8444
8445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
8446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8447 if (SWIG_arg_fail(1)) SWIG_fail;
8448 {
8449 PyThreadState* __tstate = wxPyBeginAllowThreads();
8450 delete arg1;
8451
8452 wxPyEndAllowThreads(__tstate);
8453 if (PyErr_Occurred()) SWIG_fail;
8454 }
8455 Py_INCREF(Py_None); resultobj = Py_None;
8456 return resultobj;
8457 fail:
8458 return NULL;
8459 }
8460
8461
8462 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8463 PyObject *resultobj;
8464 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8465 wxString *arg2 = 0 ;
8466 bool result;
8467 bool temp2 = false ;
8468 PyObject * obj0 = 0 ;
8469 PyObject * obj1 = 0 ;
8470 char *kwnames[] = {
8471 (char *) "self",(char *) "s", NULL
8472 };
8473
8474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8476 if (SWIG_arg_fail(1)) SWIG_fail;
8477 {
8478 arg2 = wxString_in_helper(obj1);
8479 if (arg2 == NULL) SWIG_fail;
8480 temp2 = true;
8481 }
8482 {
8483 PyThreadState* __tstate = wxPyBeginAllowThreads();
8484 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8485
8486 wxPyEndAllowThreads(__tstate);
8487 if (PyErr_Occurred()) SWIG_fail;
8488 }
8489 {
8490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8491 }
8492 {
8493 if (temp2)
8494 delete arg2;
8495 }
8496 return resultobj;
8497 fail:
8498 {
8499 if (temp2)
8500 delete arg2;
8501 }
8502 return NULL;
8503 }
8504
8505
8506 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8507 PyObject *resultobj;
8508 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8509 wxString result;
8510 PyObject * obj0 = 0 ;
8511 char *kwnames[] = {
8512 (char *) "self", NULL
8513 };
8514
8515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
8516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8517 if (SWIG_arg_fail(1)) SWIG_fail;
8518 {
8519 PyThreadState* __tstate = wxPyBeginAllowThreads();
8520 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
8521
8522 wxPyEndAllowThreads(__tstate);
8523 if (PyErr_Occurred()) SWIG_fail;
8524 }
8525 {
8526 #if wxUSE_UNICODE
8527 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8528 #else
8529 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8530 #endif
8531 }
8532 return resultobj;
8533 fail:
8534 return NULL;
8535 }
8536
8537
8538 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
8539 PyObject *obj;
8540 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8541 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
8542 Py_INCREF(obj);
8543 return Py_BuildValue((char *)"");
8544 }
8545 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8546 PyObject *resultobj;
8547 wxFontEncoding arg1 ;
8548 wxNativeEncodingInfo *result;
8549 PyObject * obj0 = 0 ;
8550 char *kwnames[] = {
8551 (char *) "encoding", NULL
8552 };
8553
8554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
8555 {
8556 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8557 if (SWIG_arg_fail(1)) SWIG_fail;
8558 }
8559 {
8560 PyThreadState* __tstate = wxPyBeginAllowThreads();
8561 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
8562
8563 wxPyEndAllowThreads(__tstate);
8564 if (PyErr_Occurred()) SWIG_fail;
8565 }
8566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
8567 return resultobj;
8568 fail:
8569 return NULL;
8570 }
8571
8572
8573 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8574 PyObject *resultobj;
8575 wxNativeEncodingInfo *arg1 = 0 ;
8576 bool result;
8577 PyObject * obj0 = 0 ;
8578 char *kwnames[] = {
8579 (char *) "info", NULL
8580 };
8581
8582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
8583 {
8584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8585 if (SWIG_arg_fail(1)) SWIG_fail;
8586 if (arg1 == NULL) {
8587 SWIG_null_ref("wxNativeEncodingInfo");
8588 }
8589 if (SWIG_arg_fail(1)) SWIG_fail;
8590 }
8591 {
8592 PyThreadState* __tstate = wxPyBeginAllowThreads();
8593 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
8594
8595 wxPyEndAllowThreads(__tstate);
8596 if (PyErr_Occurred()) SWIG_fail;
8597 }
8598 {
8599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8600 }
8601 return resultobj;
8602 fail:
8603 return NULL;
8604 }
8605
8606
8607 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8608 PyObject *resultobj;
8609 wxFontMapper *result;
8610 char *kwnames[] = {
8611 NULL
8612 };
8613
8614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
8615 {
8616 PyThreadState* __tstate = wxPyBeginAllowThreads();
8617 result = (wxFontMapper *)new wxFontMapper();
8618
8619 wxPyEndAllowThreads(__tstate);
8620 if (PyErr_Occurred()) SWIG_fail;
8621 }
8622 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
8623 return resultobj;
8624 fail:
8625 return NULL;
8626 }
8627
8628
8629 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8630 PyObject *resultobj;
8631 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8632 PyObject * obj0 = 0 ;
8633 char *kwnames[] = {
8634 (char *) "self", NULL
8635 };
8636
8637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
8638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8639 if (SWIG_arg_fail(1)) SWIG_fail;
8640 {
8641 PyThreadState* __tstate = wxPyBeginAllowThreads();
8642 delete arg1;
8643
8644 wxPyEndAllowThreads(__tstate);
8645 if (PyErr_Occurred()) SWIG_fail;
8646 }
8647 Py_INCREF(Py_None); resultobj = Py_None;
8648 return resultobj;
8649 fail:
8650 return NULL;
8651 }
8652
8653
8654 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
8655 PyObject *resultobj;
8656 wxFontMapper *result;
8657 char *kwnames[] = {
8658 NULL
8659 };
8660
8661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
8662 {
8663 PyThreadState* __tstate = wxPyBeginAllowThreads();
8664 result = (wxFontMapper *)wxFontMapper::Get();
8665
8666 wxPyEndAllowThreads(__tstate);
8667 if (PyErr_Occurred()) SWIG_fail;
8668 }
8669 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8670 return resultobj;
8671 fail:
8672 return NULL;
8673 }
8674
8675
8676 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
8677 PyObject *resultobj;
8678 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8679 wxFontMapper *result;
8680 PyObject * obj0 = 0 ;
8681 char *kwnames[] = {
8682 (char *) "mapper", NULL
8683 };
8684
8685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
8686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8687 if (SWIG_arg_fail(1)) SWIG_fail;
8688 {
8689 PyThreadState* __tstate = wxPyBeginAllowThreads();
8690 result = (wxFontMapper *)wxFontMapper::Set(arg1);
8691
8692 wxPyEndAllowThreads(__tstate);
8693 if (PyErr_Occurred()) SWIG_fail;
8694 }
8695 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8696 return resultobj;
8697 fail:
8698 return NULL;
8699 }
8700
8701
8702 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8703 PyObject *resultobj;
8704 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8705 wxString *arg2 = 0 ;
8706 bool arg3 = (bool) true ;
8707 wxFontEncoding result;
8708 bool temp2 = false ;
8709 PyObject * obj0 = 0 ;
8710 PyObject * obj1 = 0 ;
8711 PyObject * obj2 = 0 ;
8712 char *kwnames[] = {
8713 (char *) "self",(char *) "charset",(char *) "interactive", NULL
8714 };
8715
8716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
8717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8718 if (SWIG_arg_fail(1)) SWIG_fail;
8719 {
8720 arg2 = wxString_in_helper(obj1);
8721 if (arg2 == NULL) SWIG_fail;
8722 temp2 = true;
8723 }
8724 if (obj2) {
8725 {
8726 arg3 = (bool)(SWIG_As_bool(obj2));
8727 if (SWIG_arg_fail(3)) SWIG_fail;
8728 }
8729 }
8730 {
8731 PyThreadState* __tstate = wxPyBeginAllowThreads();
8732 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
8733
8734 wxPyEndAllowThreads(__tstate);
8735 if (PyErr_Occurred()) SWIG_fail;
8736 }
8737 resultobj = SWIG_From_int((result));
8738 {
8739 if (temp2)
8740 delete arg2;
8741 }
8742 return resultobj;
8743 fail:
8744 {
8745 if (temp2)
8746 delete arg2;
8747 }
8748 return NULL;
8749 }
8750
8751
8752 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
8753 PyObject *resultobj;
8754 size_t result;
8755 char *kwnames[] = {
8756 NULL
8757 };
8758
8759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
8760 {
8761 PyThreadState* __tstate = wxPyBeginAllowThreads();
8762 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
8763
8764 wxPyEndAllowThreads(__tstate);
8765 if (PyErr_Occurred()) SWIG_fail;
8766 }
8767 {
8768 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8769 }
8770 return resultobj;
8771 fail:
8772 return NULL;
8773 }
8774
8775
8776 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8777 PyObject *resultobj;
8778 size_t arg1 ;
8779 wxFontEncoding result;
8780 PyObject * obj0 = 0 ;
8781 char *kwnames[] = {
8782 (char *) "n", NULL
8783 };
8784
8785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
8786 {
8787 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8788 if (SWIG_arg_fail(1)) SWIG_fail;
8789 }
8790 {
8791 PyThreadState* __tstate = wxPyBeginAllowThreads();
8792 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
8793
8794 wxPyEndAllowThreads(__tstate);
8795 if (PyErr_Occurred()) SWIG_fail;
8796 }
8797 resultobj = SWIG_From_int((result));
8798 return resultobj;
8799 fail:
8800 return NULL;
8801 }
8802
8803
8804 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
8805 PyObject *resultobj;
8806 wxFontEncoding arg1 ;
8807 wxString result;
8808 PyObject * obj0 = 0 ;
8809 char *kwnames[] = {
8810 (char *) "encoding", NULL
8811 };
8812
8813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
8814 {
8815 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8816 if (SWIG_arg_fail(1)) SWIG_fail;
8817 }
8818 {
8819 PyThreadState* __tstate = wxPyBeginAllowThreads();
8820 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
8821
8822 wxPyEndAllowThreads(__tstate);
8823 if (PyErr_Occurred()) SWIG_fail;
8824 }
8825 {
8826 #if wxUSE_UNICODE
8827 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8828 #else
8829 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8830 #endif
8831 }
8832 return resultobj;
8833 fail:
8834 return NULL;
8835 }
8836
8837
8838 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
8839 PyObject *resultobj;
8840 wxFontEncoding arg1 ;
8841 wxString result;
8842 PyObject * obj0 = 0 ;
8843 char *kwnames[] = {
8844 (char *) "encoding", NULL
8845 };
8846
8847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
8848 {
8849 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8850 if (SWIG_arg_fail(1)) SWIG_fail;
8851 }
8852 {
8853 PyThreadState* __tstate = wxPyBeginAllowThreads();
8854 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
8855
8856 wxPyEndAllowThreads(__tstate);
8857 if (PyErr_Occurred()) SWIG_fail;
8858 }
8859 {
8860 #if wxUSE_UNICODE
8861 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8862 #else
8863 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8864 #endif
8865 }
8866 return resultobj;
8867 fail:
8868 return NULL;
8869 }
8870
8871
8872 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
8873 PyObject *resultobj;
8874 wxString *arg1 = 0 ;
8875 wxFontEncoding result;
8876 bool temp1 = false ;
8877 PyObject * obj0 = 0 ;
8878 char *kwnames[] = {
8879 (char *) "name", NULL
8880 };
8881
8882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
8883 {
8884 arg1 = wxString_in_helper(obj0);
8885 if (arg1 == NULL) SWIG_fail;
8886 temp1 = true;
8887 }
8888 {
8889 PyThreadState* __tstate = wxPyBeginAllowThreads();
8890 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
8891
8892 wxPyEndAllowThreads(__tstate);
8893 if (PyErr_Occurred()) SWIG_fail;
8894 }
8895 resultobj = SWIG_From_int((result));
8896 {
8897 if (temp1)
8898 delete arg1;
8899 }
8900 return resultobj;
8901 fail:
8902 {
8903 if (temp1)
8904 delete arg1;
8905 }
8906 return NULL;
8907 }
8908
8909
8910 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
8911 PyObject *resultobj;
8912 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8913 wxConfigBase *arg2 = (wxConfigBase *) 0 ;
8914 PyObject * obj0 = 0 ;
8915 PyObject * obj1 = 0 ;
8916 char *kwnames[] = {
8917 (char *) "self",(char *) "config", NULL
8918 };
8919
8920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
8921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8922 if (SWIG_arg_fail(1)) SWIG_fail;
8923 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8924 if (SWIG_arg_fail(2)) SWIG_fail;
8925 {
8926 PyThreadState* __tstate = wxPyBeginAllowThreads();
8927 (arg1)->SetConfig(arg2);
8928
8929 wxPyEndAllowThreads(__tstate);
8930 if (PyErr_Occurred()) SWIG_fail;
8931 }
8932 Py_INCREF(Py_None); resultobj = Py_None;
8933 return resultobj;
8934 fail:
8935 return NULL;
8936 }
8937
8938
8939 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8940 PyObject *resultobj;
8941 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8942 wxString *arg2 = 0 ;
8943 bool temp2 = false ;
8944 PyObject * obj0 = 0 ;
8945 PyObject * obj1 = 0 ;
8946 char *kwnames[] = {
8947 (char *) "self",(char *) "prefix", NULL
8948 };
8949
8950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
8951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8952 if (SWIG_arg_fail(1)) SWIG_fail;
8953 {
8954 arg2 = wxString_in_helper(obj1);
8955 if (arg2 == NULL) SWIG_fail;
8956 temp2 = true;
8957 }
8958 {
8959 PyThreadState* __tstate = wxPyBeginAllowThreads();
8960 (arg1)->SetConfigPath((wxString const &)*arg2);
8961
8962 wxPyEndAllowThreads(__tstate);
8963 if (PyErr_Occurred()) SWIG_fail;
8964 }
8965 Py_INCREF(Py_None); resultobj = Py_None;
8966 {
8967 if (temp2)
8968 delete arg2;
8969 }
8970 return resultobj;
8971 fail:
8972 {
8973 if (temp2)
8974 delete arg2;
8975 }
8976 return NULL;
8977 }
8978
8979
8980 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8981 PyObject *resultobj;
8982 wxString result;
8983 char *kwnames[] = {
8984 NULL
8985 };
8986
8987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
8988 {
8989 PyThreadState* __tstate = wxPyBeginAllowThreads();
8990 result = wxFontMapper::GetDefaultConfigPath();
8991
8992 wxPyEndAllowThreads(__tstate);
8993 if (PyErr_Occurred()) SWIG_fail;
8994 }
8995 {
8996 #if wxUSE_UNICODE
8997 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8998 #else
8999 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9000 #endif
9001 }
9002 return resultobj;
9003 fail:
9004 return NULL;
9005 }
9006
9007
9008 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9009 PyObject *resultobj;
9010 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9011 wxFontEncoding arg2 ;
9012 wxString const &arg3_defvalue = wxPyEmptyString ;
9013 wxString *arg3 = (wxString *) &arg3_defvalue ;
9014 bool arg4 = (bool) true ;
9015 PyObject *result;
9016 bool temp3 = false ;
9017 PyObject * obj0 = 0 ;
9018 PyObject * obj1 = 0 ;
9019 PyObject * obj2 = 0 ;
9020 PyObject * obj3 = 0 ;
9021 char *kwnames[] = {
9022 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
9023 };
9024
9025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9027 if (SWIG_arg_fail(1)) SWIG_fail;
9028 {
9029 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9030 if (SWIG_arg_fail(2)) SWIG_fail;
9031 }
9032 if (obj2) {
9033 {
9034 arg3 = wxString_in_helper(obj2);
9035 if (arg3 == NULL) SWIG_fail;
9036 temp3 = true;
9037 }
9038 }
9039 if (obj3) {
9040 {
9041 arg4 = (bool)(SWIG_As_bool(obj3));
9042 if (SWIG_arg_fail(4)) SWIG_fail;
9043 }
9044 }
9045 {
9046 PyThreadState* __tstate = wxPyBeginAllowThreads();
9047 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9048
9049 wxPyEndAllowThreads(__tstate);
9050 if (PyErr_Occurred()) SWIG_fail;
9051 }
9052 resultobj = result;
9053 {
9054 if (temp3)
9055 delete arg3;
9056 }
9057 return resultobj;
9058 fail:
9059 {
9060 if (temp3)
9061 delete arg3;
9062 }
9063 return NULL;
9064 }
9065
9066
9067 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9068 PyObject *resultobj;
9069 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9070 wxFontEncoding arg2 ;
9071 wxString const &arg3_defvalue = wxPyEmptyString ;
9072 wxString *arg3 = (wxString *) &arg3_defvalue ;
9073 bool result;
9074 bool temp3 = false ;
9075 PyObject * obj0 = 0 ;
9076 PyObject * obj1 = 0 ;
9077 PyObject * obj2 = 0 ;
9078 char *kwnames[] = {
9079 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9080 };
9081
9082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9084 if (SWIG_arg_fail(1)) SWIG_fail;
9085 {
9086 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9087 if (SWIG_arg_fail(2)) SWIG_fail;
9088 }
9089 if (obj2) {
9090 {
9091 arg3 = wxString_in_helper(obj2);
9092 if (arg3 == NULL) SWIG_fail;
9093 temp3 = true;
9094 }
9095 }
9096 {
9097 PyThreadState* __tstate = wxPyBeginAllowThreads();
9098 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9099
9100 wxPyEndAllowThreads(__tstate);
9101 if (PyErr_Occurred()) SWIG_fail;
9102 }
9103 {
9104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9105 }
9106 {
9107 if (temp3)
9108 delete arg3;
9109 }
9110 return resultobj;
9111 fail:
9112 {
9113 if (temp3)
9114 delete arg3;
9115 }
9116 return NULL;
9117 }
9118
9119
9120 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9121 PyObject *resultobj;
9122 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9123 wxWindow *arg2 = (wxWindow *) 0 ;
9124 PyObject * obj0 = 0 ;
9125 PyObject * obj1 = 0 ;
9126 char *kwnames[] = {
9127 (char *) "self",(char *) "parent", NULL
9128 };
9129
9130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9132 if (SWIG_arg_fail(1)) SWIG_fail;
9133 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9134 if (SWIG_arg_fail(2)) SWIG_fail;
9135 {
9136 PyThreadState* __tstate = wxPyBeginAllowThreads();
9137 (arg1)->SetDialogParent(arg2);
9138
9139 wxPyEndAllowThreads(__tstate);
9140 if (PyErr_Occurred()) SWIG_fail;
9141 }
9142 Py_INCREF(Py_None); resultobj = Py_None;
9143 return resultobj;
9144 fail:
9145 return NULL;
9146 }
9147
9148
9149 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9150 PyObject *resultobj;
9151 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9152 wxString *arg2 = 0 ;
9153 bool temp2 = false ;
9154 PyObject * obj0 = 0 ;
9155 PyObject * obj1 = 0 ;
9156 char *kwnames[] = {
9157 (char *) "self",(char *) "title", NULL
9158 };
9159
9160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9162 if (SWIG_arg_fail(1)) SWIG_fail;
9163 {
9164 arg2 = wxString_in_helper(obj1);
9165 if (arg2 == NULL) SWIG_fail;
9166 temp2 = true;
9167 }
9168 {
9169 PyThreadState* __tstate = wxPyBeginAllowThreads();
9170 (arg1)->SetDialogTitle((wxString const &)*arg2);
9171
9172 wxPyEndAllowThreads(__tstate);
9173 if (PyErr_Occurred()) SWIG_fail;
9174 }
9175 Py_INCREF(Py_None); resultobj = Py_None;
9176 {
9177 if (temp2)
9178 delete arg2;
9179 }
9180 return resultobj;
9181 fail:
9182 {
9183 if (temp2)
9184 delete arg2;
9185 }
9186 return NULL;
9187 }
9188
9189
9190 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9191 PyObject *obj;
9192 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9193 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9194 Py_INCREF(obj);
9195 return Py_BuildValue((char *)"");
9196 }
9197 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9198 PyObject *resultobj;
9199 int arg1 ;
9200 int arg2 ;
9201 int arg3 ;
9202 int arg4 ;
9203 bool arg5 = (bool) false ;
9204 wxString const &arg6_defvalue = wxPyEmptyString ;
9205 wxString *arg6 = (wxString *) &arg6_defvalue ;
9206 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9207 wxFont *result;
9208 bool temp6 = false ;
9209 PyObject * obj0 = 0 ;
9210 PyObject * obj1 = 0 ;
9211 PyObject * obj2 = 0 ;
9212 PyObject * obj3 = 0 ;
9213 PyObject * obj4 = 0 ;
9214 PyObject * obj5 = 0 ;
9215 PyObject * obj6 = 0 ;
9216 char *kwnames[] = {
9217 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9218 };
9219
9220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9221 {
9222 arg1 = (int)(SWIG_As_int(obj0));
9223 if (SWIG_arg_fail(1)) SWIG_fail;
9224 }
9225 {
9226 arg2 = (int)(SWIG_As_int(obj1));
9227 if (SWIG_arg_fail(2)) SWIG_fail;
9228 }
9229 {
9230 arg3 = (int)(SWIG_As_int(obj2));
9231 if (SWIG_arg_fail(3)) SWIG_fail;
9232 }
9233 {
9234 arg4 = (int)(SWIG_As_int(obj3));
9235 if (SWIG_arg_fail(4)) SWIG_fail;
9236 }
9237 if (obj4) {
9238 {
9239 arg5 = (bool)(SWIG_As_bool(obj4));
9240 if (SWIG_arg_fail(5)) SWIG_fail;
9241 }
9242 }
9243 if (obj5) {
9244 {
9245 arg6 = wxString_in_helper(obj5);
9246 if (arg6 == NULL) SWIG_fail;
9247 temp6 = true;
9248 }
9249 }
9250 if (obj6) {
9251 {
9252 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9253 if (SWIG_arg_fail(7)) SWIG_fail;
9254 }
9255 }
9256 {
9257 if (!wxPyCheckForApp()) SWIG_fail;
9258 PyThreadState* __tstate = wxPyBeginAllowThreads();
9259 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9260
9261 wxPyEndAllowThreads(__tstate);
9262 if (PyErr_Occurred()) SWIG_fail;
9263 }
9264 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9265 {
9266 if (temp6)
9267 delete arg6;
9268 }
9269 return resultobj;
9270 fail:
9271 {
9272 if (temp6)
9273 delete arg6;
9274 }
9275 return NULL;
9276 }
9277
9278
9279 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9280 PyObject *resultobj;
9281 wxFont *arg1 = (wxFont *) 0 ;
9282 PyObject * obj0 = 0 ;
9283 char *kwnames[] = {
9284 (char *) "self", NULL
9285 };
9286
9287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9289 if (SWIG_arg_fail(1)) SWIG_fail;
9290 {
9291 PyThreadState* __tstate = wxPyBeginAllowThreads();
9292 delete arg1;
9293
9294 wxPyEndAllowThreads(__tstate);
9295 if (PyErr_Occurred()) SWIG_fail;
9296 }
9297 Py_INCREF(Py_None); resultobj = Py_None;
9298 return resultobj;
9299 fail:
9300 return NULL;
9301 }
9302
9303
9304 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9305 PyObject *resultobj;
9306 wxNativeFontInfo *arg1 = 0 ;
9307 wxFont *result;
9308 PyObject * obj0 = 0 ;
9309 char *kwnames[] = {
9310 (char *) "info", NULL
9311 };
9312
9313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9314 {
9315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9316 if (SWIG_arg_fail(1)) SWIG_fail;
9317 if (arg1 == NULL) {
9318 SWIG_null_ref("wxNativeFontInfo");
9319 }
9320 if (SWIG_arg_fail(1)) SWIG_fail;
9321 }
9322 {
9323 if (!wxPyCheckForApp()) SWIG_fail;
9324 PyThreadState* __tstate = wxPyBeginAllowThreads();
9325 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9326
9327 wxPyEndAllowThreads(__tstate);
9328 if (PyErr_Occurred()) SWIG_fail;
9329 }
9330 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9331 return resultobj;
9332 fail:
9333 return NULL;
9334 }
9335
9336
9337 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9338 PyObject *resultobj;
9339 wxString *arg1 = 0 ;
9340 wxFont *result;
9341 bool temp1 = false ;
9342 PyObject * obj0 = 0 ;
9343 char *kwnames[] = {
9344 (char *) "info", NULL
9345 };
9346
9347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9348 {
9349 arg1 = wxString_in_helper(obj0);
9350 if (arg1 == NULL) SWIG_fail;
9351 temp1 = true;
9352 }
9353 {
9354 if (!wxPyCheckForApp()) SWIG_fail;
9355 PyThreadState* __tstate = wxPyBeginAllowThreads();
9356 result = (wxFont *)new_wxFont((wxString const &)*arg1);
9357
9358 wxPyEndAllowThreads(__tstate);
9359 if (PyErr_Occurred()) SWIG_fail;
9360 }
9361 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9362 {
9363 if (temp1)
9364 delete arg1;
9365 }
9366 return resultobj;
9367 fail:
9368 {
9369 if (temp1)
9370 delete arg1;
9371 }
9372 return NULL;
9373 }
9374
9375
9376 static PyObject *_wrap_new_Font2(PyObject *, PyObject *args, PyObject *kwargs) {
9377 PyObject *resultobj;
9378 int arg1 ;
9379 wxFontFamily arg2 ;
9380 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9381 wxString const &arg4_defvalue = wxPyEmptyString ;
9382 wxString *arg4 = (wxString *) &arg4_defvalue ;
9383 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9384 wxFont *result;
9385 bool temp4 = false ;
9386 PyObject * obj0 = 0 ;
9387 PyObject * obj1 = 0 ;
9388 PyObject * obj2 = 0 ;
9389 PyObject * obj3 = 0 ;
9390 PyObject * obj4 = 0 ;
9391 char *kwnames[] = {
9392 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9393 };
9394
9395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_Font2",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9396 {
9397 arg1 = (int)(SWIG_As_int(obj0));
9398 if (SWIG_arg_fail(1)) SWIG_fail;
9399 }
9400 {
9401 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9402 if (SWIG_arg_fail(2)) SWIG_fail;
9403 }
9404 if (obj2) {
9405 {
9406 arg3 = (int)(SWIG_As_int(obj2));
9407 if (SWIG_arg_fail(3)) SWIG_fail;
9408 }
9409 }
9410 if (obj3) {
9411 {
9412 arg4 = wxString_in_helper(obj3);
9413 if (arg4 == NULL) SWIG_fail;
9414 temp4 = true;
9415 }
9416 }
9417 if (obj4) {
9418 {
9419 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9420 if (SWIG_arg_fail(5)) SWIG_fail;
9421 }
9422 }
9423 {
9424 if (!wxPyCheckForApp()) SWIG_fail;
9425 PyThreadState* __tstate = wxPyBeginAllowThreads();
9426 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9427
9428 wxPyEndAllowThreads(__tstate);
9429 if (PyErr_Occurred()) SWIG_fail;
9430 }
9431 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9432 {
9433 if (temp4)
9434 delete arg4;
9435 }
9436 return resultobj;
9437 fail:
9438 {
9439 if (temp4)
9440 delete arg4;
9441 }
9442 return NULL;
9443 }
9444
9445
9446 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9447 PyObject *resultobj;
9448 wxSize *arg1 = 0 ;
9449 int arg2 ;
9450 int arg3 ;
9451 int arg4 ;
9452 bool arg5 = (bool) false ;
9453 wxString const &arg6_defvalue = wxEmptyString ;
9454 wxString *arg6 = (wxString *) &arg6_defvalue ;
9455 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9456 wxFont *result;
9457 wxSize temp1 ;
9458 bool temp6 = false ;
9459 PyObject * obj0 = 0 ;
9460 PyObject * obj1 = 0 ;
9461 PyObject * obj2 = 0 ;
9462 PyObject * obj3 = 0 ;
9463 PyObject * obj4 = 0 ;
9464 PyObject * obj5 = 0 ;
9465 PyObject * obj6 = 0 ;
9466 char *kwnames[] = {
9467 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
9468 };
9469
9470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9471 {
9472 arg1 = &temp1;
9473 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9474 }
9475 {
9476 arg2 = (int)(SWIG_As_int(obj1));
9477 if (SWIG_arg_fail(2)) SWIG_fail;
9478 }
9479 {
9480 arg3 = (int)(SWIG_As_int(obj2));
9481 if (SWIG_arg_fail(3)) SWIG_fail;
9482 }
9483 {
9484 arg4 = (int)(SWIG_As_int(obj3));
9485 if (SWIG_arg_fail(4)) SWIG_fail;
9486 }
9487 if (obj4) {
9488 {
9489 arg5 = (bool)(SWIG_As_bool(obj4));
9490 if (SWIG_arg_fail(5)) SWIG_fail;
9491 }
9492 }
9493 if (obj5) {
9494 {
9495 arg6 = wxString_in_helper(obj5);
9496 if (arg6 == NULL) SWIG_fail;
9497 temp6 = true;
9498 }
9499 }
9500 if (obj6) {
9501 {
9502 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9503 if (SWIG_arg_fail(7)) SWIG_fail;
9504 }
9505 }
9506 {
9507 if (!wxPyCheckForApp()) SWIG_fail;
9508 PyThreadState* __tstate = wxPyBeginAllowThreads();
9509 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9510
9511 wxPyEndAllowThreads(__tstate);
9512 if (PyErr_Occurred()) SWIG_fail;
9513 }
9514 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9515 {
9516 if (temp6)
9517 delete arg6;
9518 }
9519 return resultobj;
9520 fail:
9521 {
9522 if (temp6)
9523 delete arg6;
9524 }
9525 return NULL;
9526 }
9527
9528
9529 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
9530 PyObject *resultobj;
9531 wxFont *arg1 = (wxFont *) 0 ;
9532 bool result;
9533 PyObject * obj0 = 0 ;
9534 char *kwnames[] = {
9535 (char *) "self", NULL
9536 };
9537
9538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
9539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9540 if (SWIG_arg_fail(1)) SWIG_fail;
9541 {
9542 PyThreadState* __tstate = wxPyBeginAllowThreads();
9543 result = (bool)((wxFont const *)arg1)->Ok();
9544
9545 wxPyEndAllowThreads(__tstate);
9546 if (PyErr_Occurred()) SWIG_fail;
9547 }
9548 {
9549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9550 }
9551 return resultobj;
9552 fail:
9553 return NULL;
9554 }
9555
9556
9557 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9558 PyObject *resultobj;
9559 wxFont *arg1 = (wxFont *) 0 ;
9560 wxFont *arg2 = (wxFont *) 0 ;
9561 bool result;
9562 PyObject * obj0 = 0 ;
9563 PyObject * obj1 = 0 ;
9564 char *kwnames[] = {
9565 (char *) "self",(char *) "other", NULL
9566 };
9567
9568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
9569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9570 if (SWIG_arg_fail(1)) SWIG_fail;
9571 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9572 if (SWIG_arg_fail(2)) SWIG_fail;
9573 {
9574 PyThreadState* __tstate = wxPyBeginAllowThreads();
9575 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
9576
9577 wxPyEndAllowThreads(__tstate);
9578 if (PyErr_Occurred()) SWIG_fail;
9579 }
9580 {
9581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9582 }
9583 return resultobj;
9584 fail:
9585 return NULL;
9586 }
9587
9588
9589 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9590 PyObject *resultobj;
9591 wxFont *arg1 = (wxFont *) 0 ;
9592 wxFont *arg2 = (wxFont *) 0 ;
9593 bool result;
9594 PyObject * obj0 = 0 ;
9595 PyObject * obj1 = 0 ;
9596 char *kwnames[] = {
9597 (char *) "self",(char *) "other", NULL
9598 };
9599
9600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
9601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9602 if (SWIG_arg_fail(1)) SWIG_fail;
9603 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9604 if (SWIG_arg_fail(2)) SWIG_fail;
9605 {
9606 PyThreadState* __tstate = wxPyBeginAllowThreads();
9607 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
9608
9609 wxPyEndAllowThreads(__tstate);
9610 if (PyErr_Occurred()) SWIG_fail;
9611 }
9612 {
9613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9614 }
9615 return resultobj;
9616 fail:
9617 return NULL;
9618 }
9619
9620
9621 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9622 PyObject *resultobj;
9623 wxFont *arg1 = (wxFont *) 0 ;
9624 int result;
9625 PyObject * obj0 = 0 ;
9626 char *kwnames[] = {
9627 (char *) "self", NULL
9628 };
9629
9630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
9631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9632 if (SWIG_arg_fail(1)) SWIG_fail;
9633 {
9634 PyThreadState* __tstate = wxPyBeginAllowThreads();
9635 result = (int)((wxFont const *)arg1)->GetPointSize();
9636
9637 wxPyEndAllowThreads(__tstate);
9638 if (PyErr_Occurred()) SWIG_fail;
9639 }
9640 {
9641 resultobj = SWIG_From_int((int)(result));
9642 }
9643 return resultobj;
9644 fail:
9645 return NULL;
9646 }
9647
9648
9649 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9650 PyObject *resultobj;
9651 wxFont *arg1 = (wxFont *) 0 ;
9652 wxSize result;
9653 PyObject * obj0 = 0 ;
9654 char *kwnames[] = {
9655 (char *) "self", NULL
9656 };
9657
9658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
9659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9660 if (SWIG_arg_fail(1)) SWIG_fail;
9661 {
9662 PyThreadState* __tstate = wxPyBeginAllowThreads();
9663 result = ((wxFont const *)arg1)->GetPixelSize();
9664
9665 wxPyEndAllowThreads(__tstate);
9666 if (PyErr_Occurred()) SWIG_fail;
9667 }
9668 {
9669 wxSize * resultptr;
9670 resultptr = new wxSize((wxSize &)(result));
9671 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
9672 }
9673 return resultobj;
9674 fail:
9675 return NULL;
9676 }
9677
9678
9679 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
9680 PyObject *resultobj;
9681 wxFont *arg1 = (wxFont *) 0 ;
9682 bool result;
9683 PyObject * obj0 = 0 ;
9684 char *kwnames[] = {
9685 (char *) "self", NULL
9686 };
9687
9688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
9689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9690 if (SWIG_arg_fail(1)) SWIG_fail;
9691 {
9692 PyThreadState* __tstate = wxPyBeginAllowThreads();
9693 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
9694
9695 wxPyEndAllowThreads(__tstate);
9696 if (PyErr_Occurred()) SWIG_fail;
9697 }
9698 {
9699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9700 }
9701 return resultobj;
9702 fail:
9703 return NULL;
9704 }
9705
9706
9707 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
9708 PyObject *resultobj;
9709 wxFont *arg1 = (wxFont *) 0 ;
9710 int result;
9711 PyObject * obj0 = 0 ;
9712 char *kwnames[] = {
9713 (char *) "self", NULL
9714 };
9715
9716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
9717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9718 if (SWIG_arg_fail(1)) SWIG_fail;
9719 {
9720 PyThreadState* __tstate = wxPyBeginAllowThreads();
9721 result = (int)((wxFont const *)arg1)->GetFamily();
9722
9723 wxPyEndAllowThreads(__tstate);
9724 if (PyErr_Occurred()) SWIG_fail;
9725 }
9726 {
9727 resultobj = SWIG_From_int((int)(result));
9728 }
9729 return resultobj;
9730 fail:
9731 return NULL;
9732 }
9733
9734
9735 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
9736 PyObject *resultobj;
9737 wxFont *arg1 = (wxFont *) 0 ;
9738 int result;
9739 PyObject * obj0 = 0 ;
9740 char *kwnames[] = {
9741 (char *) "self", NULL
9742 };
9743
9744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
9745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9746 if (SWIG_arg_fail(1)) SWIG_fail;
9747 {
9748 PyThreadState* __tstate = wxPyBeginAllowThreads();
9749 result = (int)((wxFont const *)arg1)->GetStyle();
9750
9751 wxPyEndAllowThreads(__tstate);
9752 if (PyErr_Occurred()) SWIG_fail;
9753 }
9754 {
9755 resultobj = SWIG_From_int((int)(result));
9756 }
9757 return resultobj;
9758 fail:
9759 return NULL;
9760 }
9761
9762
9763 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
9764 PyObject *resultobj;
9765 wxFont *arg1 = (wxFont *) 0 ;
9766 int result;
9767 PyObject * obj0 = 0 ;
9768 char *kwnames[] = {
9769 (char *) "self", NULL
9770 };
9771
9772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
9773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9774 if (SWIG_arg_fail(1)) SWIG_fail;
9775 {
9776 PyThreadState* __tstate = wxPyBeginAllowThreads();
9777 result = (int)((wxFont const *)arg1)->GetWeight();
9778
9779 wxPyEndAllowThreads(__tstate);
9780 if (PyErr_Occurred()) SWIG_fail;
9781 }
9782 {
9783 resultobj = SWIG_From_int((int)(result));
9784 }
9785 return resultobj;
9786 fail:
9787 return NULL;
9788 }
9789
9790
9791 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
9792 PyObject *resultobj;
9793 wxFont *arg1 = (wxFont *) 0 ;
9794 bool result;
9795 PyObject * obj0 = 0 ;
9796 char *kwnames[] = {
9797 (char *) "self", NULL
9798 };
9799
9800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
9801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9802 if (SWIG_arg_fail(1)) SWIG_fail;
9803 {
9804 PyThreadState* __tstate = wxPyBeginAllowThreads();
9805 result = (bool)((wxFont const *)arg1)->GetUnderlined();
9806
9807 wxPyEndAllowThreads(__tstate);
9808 if (PyErr_Occurred()) SWIG_fail;
9809 }
9810 {
9811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9812 }
9813 return resultobj;
9814 fail:
9815 return NULL;
9816 }
9817
9818
9819 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
9820 PyObject *resultobj;
9821 wxFont *arg1 = (wxFont *) 0 ;
9822 wxString result;
9823 PyObject * obj0 = 0 ;
9824 char *kwnames[] = {
9825 (char *) "self", NULL
9826 };
9827
9828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
9829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9830 if (SWIG_arg_fail(1)) SWIG_fail;
9831 {
9832 PyThreadState* __tstate = wxPyBeginAllowThreads();
9833 result = ((wxFont const *)arg1)->GetFaceName();
9834
9835 wxPyEndAllowThreads(__tstate);
9836 if (PyErr_Occurred()) SWIG_fail;
9837 }
9838 {
9839 #if wxUSE_UNICODE
9840 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9841 #else
9842 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9843 #endif
9844 }
9845 return resultobj;
9846 fail:
9847 return NULL;
9848 }
9849
9850
9851 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9852 PyObject *resultobj;
9853 wxFont *arg1 = (wxFont *) 0 ;
9854 wxFontEncoding result;
9855 PyObject * obj0 = 0 ;
9856 char *kwnames[] = {
9857 (char *) "self", NULL
9858 };
9859
9860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
9861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9862 if (SWIG_arg_fail(1)) SWIG_fail;
9863 {
9864 PyThreadState* __tstate = wxPyBeginAllowThreads();
9865 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
9866
9867 wxPyEndAllowThreads(__tstate);
9868 if (PyErr_Occurred()) SWIG_fail;
9869 }
9870 resultobj = SWIG_From_int((result));
9871 return resultobj;
9872 fail:
9873 return NULL;
9874 }
9875
9876
9877 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9878 PyObject *resultobj;
9879 wxFont *arg1 = (wxFont *) 0 ;
9880 wxNativeFontInfo *result;
9881 PyObject * obj0 = 0 ;
9882 char *kwnames[] = {
9883 (char *) "self", NULL
9884 };
9885
9886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
9887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9888 if (SWIG_arg_fail(1)) SWIG_fail;
9889 {
9890 PyThreadState* __tstate = wxPyBeginAllowThreads();
9891 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
9892
9893 wxPyEndAllowThreads(__tstate);
9894 if (PyErr_Occurred()) SWIG_fail;
9895 }
9896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
9897 return resultobj;
9898 fail:
9899 return NULL;
9900 }
9901
9902
9903 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
9904 PyObject *resultobj;
9905 wxFont *arg1 = (wxFont *) 0 ;
9906 bool result;
9907 PyObject * obj0 = 0 ;
9908 char *kwnames[] = {
9909 (char *) "self", NULL
9910 };
9911
9912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
9913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9914 if (SWIG_arg_fail(1)) SWIG_fail;
9915 {
9916 PyThreadState* __tstate = wxPyBeginAllowThreads();
9917 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
9918
9919 wxPyEndAllowThreads(__tstate);
9920 if (PyErr_Occurred()) SWIG_fail;
9921 }
9922 {
9923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9924 }
9925 return resultobj;
9926 fail:
9927 return NULL;
9928 }
9929
9930
9931 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
9932 PyObject *resultobj;
9933 wxFont *arg1 = (wxFont *) 0 ;
9934 wxString result;
9935 PyObject * obj0 = 0 ;
9936 char *kwnames[] = {
9937 (char *) "self", NULL
9938 };
9939
9940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
9941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9942 if (SWIG_arg_fail(1)) SWIG_fail;
9943 {
9944 PyThreadState* __tstate = wxPyBeginAllowThreads();
9945 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
9946
9947 wxPyEndAllowThreads(__tstate);
9948 if (PyErr_Occurred()) SWIG_fail;
9949 }
9950 {
9951 #if wxUSE_UNICODE
9952 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9953 #else
9954 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9955 #endif
9956 }
9957 return resultobj;
9958 fail:
9959 return NULL;
9960 }
9961
9962
9963 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
9964 PyObject *resultobj;
9965 wxFont *arg1 = (wxFont *) 0 ;
9966 wxString result;
9967 PyObject * obj0 = 0 ;
9968 char *kwnames[] = {
9969 (char *) "self", NULL
9970 };
9971
9972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
9973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9974 if (SWIG_arg_fail(1)) SWIG_fail;
9975 {
9976 PyThreadState* __tstate = wxPyBeginAllowThreads();
9977 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
9978
9979 wxPyEndAllowThreads(__tstate);
9980 if (PyErr_Occurred()) SWIG_fail;
9981 }
9982 {
9983 #if wxUSE_UNICODE
9984 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9985 #else
9986 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9987 #endif
9988 }
9989 return resultobj;
9990 fail:
9991 return NULL;
9992 }
9993
9994
9995 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9996 PyObject *resultobj;
9997 wxFont *arg1 = (wxFont *) 0 ;
9998 int arg2 ;
9999 PyObject * obj0 = 0 ;
10000 PyObject * obj1 = 0 ;
10001 char *kwnames[] = {
10002 (char *) "self",(char *) "pointSize", NULL
10003 };
10004
10005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
10006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10007 if (SWIG_arg_fail(1)) SWIG_fail;
10008 {
10009 arg2 = (int)(SWIG_As_int(obj1));
10010 if (SWIG_arg_fail(2)) SWIG_fail;
10011 }
10012 {
10013 PyThreadState* __tstate = wxPyBeginAllowThreads();
10014 (arg1)->SetPointSize(arg2);
10015
10016 wxPyEndAllowThreads(__tstate);
10017 if (PyErr_Occurred()) SWIG_fail;
10018 }
10019 Py_INCREF(Py_None); resultobj = Py_None;
10020 return resultobj;
10021 fail:
10022 return NULL;
10023 }
10024
10025
10026 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10027 PyObject *resultobj;
10028 wxFont *arg1 = (wxFont *) 0 ;
10029 wxSize *arg2 = 0 ;
10030 wxSize temp2 ;
10031 PyObject * obj0 = 0 ;
10032 PyObject * obj1 = 0 ;
10033 char *kwnames[] = {
10034 (char *) "self",(char *) "pixelSize", NULL
10035 };
10036
10037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10039 if (SWIG_arg_fail(1)) SWIG_fail;
10040 {
10041 arg2 = &temp2;
10042 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10043 }
10044 {
10045 PyThreadState* __tstate = wxPyBeginAllowThreads();
10046 (arg1)->SetPixelSize((wxSize const &)*arg2);
10047
10048 wxPyEndAllowThreads(__tstate);
10049 if (PyErr_Occurred()) SWIG_fail;
10050 }
10051 Py_INCREF(Py_None); resultobj = Py_None;
10052 return resultobj;
10053 fail:
10054 return NULL;
10055 }
10056
10057
10058 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10059 PyObject *resultobj;
10060 wxFont *arg1 = (wxFont *) 0 ;
10061 int arg2 ;
10062 PyObject * obj0 = 0 ;
10063 PyObject * obj1 = 0 ;
10064 char *kwnames[] = {
10065 (char *) "self",(char *) "family", NULL
10066 };
10067
10068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10070 if (SWIG_arg_fail(1)) SWIG_fail;
10071 {
10072 arg2 = (int)(SWIG_As_int(obj1));
10073 if (SWIG_arg_fail(2)) SWIG_fail;
10074 }
10075 {
10076 PyThreadState* __tstate = wxPyBeginAllowThreads();
10077 (arg1)->SetFamily(arg2);
10078
10079 wxPyEndAllowThreads(__tstate);
10080 if (PyErr_Occurred()) SWIG_fail;
10081 }
10082 Py_INCREF(Py_None); resultobj = Py_None;
10083 return resultobj;
10084 fail:
10085 return NULL;
10086 }
10087
10088
10089 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10090 PyObject *resultobj;
10091 wxFont *arg1 = (wxFont *) 0 ;
10092 int arg2 ;
10093 PyObject * obj0 = 0 ;
10094 PyObject * obj1 = 0 ;
10095 char *kwnames[] = {
10096 (char *) "self",(char *) "style", NULL
10097 };
10098
10099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10101 if (SWIG_arg_fail(1)) SWIG_fail;
10102 {
10103 arg2 = (int)(SWIG_As_int(obj1));
10104 if (SWIG_arg_fail(2)) SWIG_fail;
10105 }
10106 {
10107 PyThreadState* __tstate = wxPyBeginAllowThreads();
10108 (arg1)->SetStyle(arg2);
10109
10110 wxPyEndAllowThreads(__tstate);
10111 if (PyErr_Occurred()) SWIG_fail;
10112 }
10113 Py_INCREF(Py_None); resultobj = Py_None;
10114 return resultobj;
10115 fail:
10116 return NULL;
10117 }
10118
10119
10120 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10121 PyObject *resultobj;
10122 wxFont *arg1 = (wxFont *) 0 ;
10123 int arg2 ;
10124 PyObject * obj0 = 0 ;
10125 PyObject * obj1 = 0 ;
10126 char *kwnames[] = {
10127 (char *) "self",(char *) "weight", NULL
10128 };
10129
10130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10132 if (SWIG_arg_fail(1)) SWIG_fail;
10133 {
10134 arg2 = (int)(SWIG_As_int(obj1));
10135 if (SWIG_arg_fail(2)) SWIG_fail;
10136 }
10137 {
10138 PyThreadState* __tstate = wxPyBeginAllowThreads();
10139 (arg1)->SetWeight(arg2);
10140
10141 wxPyEndAllowThreads(__tstate);
10142 if (PyErr_Occurred()) SWIG_fail;
10143 }
10144 Py_INCREF(Py_None); resultobj = Py_None;
10145 return resultobj;
10146 fail:
10147 return NULL;
10148 }
10149
10150
10151 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10152 PyObject *resultobj;
10153 wxFont *arg1 = (wxFont *) 0 ;
10154 wxString *arg2 = 0 ;
10155 bool temp2 = false ;
10156 PyObject * obj0 = 0 ;
10157 PyObject * obj1 = 0 ;
10158 char *kwnames[] = {
10159 (char *) "self",(char *) "faceName", NULL
10160 };
10161
10162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10164 if (SWIG_arg_fail(1)) SWIG_fail;
10165 {
10166 arg2 = wxString_in_helper(obj1);
10167 if (arg2 == NULL) SWIG_fail;
10168 temp2 = true;
10169 }
10170 {
10171 PyThreadState* __tstate = wxPyBeginAllowThreads();
10172 (arg1)->SetFaceName((wxString const &)*arg2);
10173
10174 wxPyEndAllowThreads(__tstate);
10175 if (PyErr_Occurred()) SWIG_fail;
10176 }
10177 Py_INCREF(Py_None); resultobj = Py_None;
10178 {
10179 if (temp2)
10180 delete arg2;
10181 }
10182 return resultobj;
10183 fail:
10184 {
10185 if (temp2)
10186 delete arg2;
10187 }
10188 return NULL;
10189 }
10190
10191
10192 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10193 PyObject *resultobj;
10194 wxFont *arg1 = (wxFont *) 0 ;
10195 bool arg2 ;
10196 PyObject * obj0 = 0 ;
10197 PyObject * obj1 = 0 ;
10198 char *kwnames[] = {
10199 (char *) "self",(char *) "underlined", NULL
10200 };
10201
10202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10204 if (SWIG_arg_fail(1)) SWIG_fail;
10205 {
10206 arg2 = (bool)(SWIG_As_bool(obj1));
10207 if (SWIG_arg_fail(2)) SWIG_fail;
10208 }
10209 {
10210 PyThreadState* __tstate = wxPyBeginAllowThreads();
10211 (arg1)->SetUnderlined(arg2);
10212
10213 wxPyEndAllowThreads(__tstate);
10214 if (PyErr_Occurred()) SWIG_fail;
10215 }
10216 Py_INCREF(Py_None); resultobj = Py_None;
10217 return resultobj;
10218 fail:
10219 return NULL;
10220 }
10221
10222
10223 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10224 PyObject *resultobj;
10225 wxFont *arg1 = (wxFont *) 0 ;
10226 wxFontEncoding arg2 ;
10227 PyObject * obj0 = 0 ;
10228 PyObject * obj1 = 0 ;
10229 char *kwnames[] = {
10230 (char *) "self",(char *) "encoding", NULL
10231 };
10232
10233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10235 if (SWIG_arg_fail(1)) SWIG_fail;
10236 {
10237 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10238 if (SWIG_arg_fail(2)) SWIG_fail;
10239 }
10240 {
10241 PyThreadState* __tstate = wxPyBeginAllowThreads();
10242 (arg1)->SetEncoding((wxFontEncoding )arg2);
10243
10244 wxPyEndAllowThreads(__tstate);
10245 if (PyErr_Occurred()) SWIG_fail;
10246 }
10247 Py_INCREF(Py_None); resultobj = Py_None;
10248 return resultobj;
10249 fail:
10250 return NULL;
10251 }
10252
10253
10254 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10255 PyObject *resultobj;
10256 wxFont *arg1 = (wxFont *) 0 ;
10257 wxNativeFontInfo *arg2 = 0 ;
10258 PyObject * obj0 = 0 ;
10259 PyObject * obj1 = 0 ;
10260 char *kwnames[] = {
10261 (char *) "self",(char *) "info", NULL
10262 };
10263
10264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10266 if (SWIG_arg_fail(1)) SWIG_fail;
10267 {
10268 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10269 if (SWIG_arg_fail(2)) SWIG_fail;
10270 if (arg2 == NULL) {
10271 SWIG_null_ref("wxNativeFontInfo");
10272 }
10273 if (SWIG_arg_fail(2)) SWIG_fail;
10274 }
10275 {
10276 PyThreadState* __tstate = wxPyBeginAllowThreads();
10277 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10278
10279 wxPyEndAllowThreads(__tstate);
10280 if (PyErr_Occurred()) SWIG_fail;
10281 }
10282 Py_INCREF(Py_None); resultobj = Py_None;
10283 return resultobj;
10284 fail:
10285 return NULL;
10286 }
10287
10288
10289 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10290 PyObject *resultobj;
10291 wxFont *arg1 = (wxFont *) 0 ;
10292 wxString *arg2 = 0 ;
10293 bool temp2 = false ;
10294 PyObject * obj0 = 0 ;
10295 PyObject * obj1 = 0 ;
10296 char *kwnames[] = {
10297 (char *) "self",(char *) "info", NULL
10298 };
10299
10300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10302 if (SWIG_arg_fail(1)) SWIG_fail;
10303 {
10304 arg2 = wxString_in_helper(obj1);
10305 if (arg2 == NULL) SWIG_fail;
10306 temp2 = true;
10307 }
10308 {
10309 PyThreadState* __tstate = wxPyBeginAllowThreads();
10310 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10311
10312 wxPyEndAllowThreads(__tstate);
10313 if (PyErr_Occurred()) SWIG_fail;
10314 }
10315 Py_INCREF(Py_None); resultobj = Py_None;
10316 {
10317 if (temp2)
10318 delete arg2;
10319 }
10320 return resultobj;
10321 fail:
10322 {
10323 if (temp2)
10324 delete arg2;
10325 }
10326 return NULL;
10327 }
10328
10329
10330 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10331 PyObject *resultobj;
10332 wxFont *arg1 = (wxFont *) 0 ;
10333 wxString *arg2 = 0 ;
10334 bool temp2 = false ;
10335 PyObject * obj0 = 0 ;
10336 PyObject * obj1 = 0 ;
10337 char *kwnames[] = {
10338 (char *) "self",(char *) "info", NULL
10339 };
10340
10341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10343 if (SWIG_arg_fail(1)) SWIG_fail;
10344 {
10345 arg2 = wxString_in_helper(obj1);
10346 if (arg2 == NULL) SWIG_fail;
10347 temp2 = true;
10348 }
10349 {
10350 PyThreadState* __tstate = wxPyBeginAllowThreads();
10351 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
10352
10353 wxPyEndAllowThreads(__tstate);
10354 if (PyErr_Occurred()) SWIG_fail;
10355 }
10356 Py_INCREF(Py_None); resultobj = Py_None;
10357 {
10358 if (temp2)
10359 delete arg2;
10360 }
10361 return resultobj;
10362 fail:
10363 {
10364 if (temp2)
10365 delete arg2;
10366 }
10367 return NULL;
10368 }
10369
10370
10371 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
10372 PyObject *resultobj;
10373 wxFont *arg1 = (wxFont *) 0 ;
10374 wxString result;
10375 PyObject * obj0 = 0 ;
10376 char *kwnames[] = {
10377 (char *) "self", NULL
10378 };
10379
10380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
10381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10382 if (SWIG_arg_fail(1)) SWIG_fail;
10383 {
10384 PyThreadState* __tstate = wxPyBeginAllowThreads();
10385 result = ((wxFont const *)arg1)->GetFamilyString();
10386
10387 wxPyEndAllowThreads(__tstate);
10388 if (PyErr_Occurred()) SWIG_fail;
10389 }
10390 {
10391 #if wxUSE_UNICODE
10392 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10393 #else
10394 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10395 #endif
10396 }
10397 return resultobj;
10398 fail:
10399 return NULL;
10400 }
10401
10402
10403 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
10404 PyObject *resultobj;
10405 wxFont *arg1 = (wxFont *) 0 ;
10406 wxString result;
10407 PyObject * obj0 = 0 ;
10408 char *kwnames[] = {
10409 (char *) "self", NULL
10410 };
10411
10412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
10413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10414 if (SWIG_arg_fail(1)) SWIG_fail;
10415 {
10416 PyThreadState* __tstate = wxPyBeginAllowThreads();
10417 result = ((wxFont const *)arg1)->GetStyleString();
10418
10419 wxPyEndAllowThreads(__tstate);
10420 if (PyErr_Occurred()) SWIG_fail;
10421 }
10422 {
10423 #if wxUSE_UNICODE
10424 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10425 #else
10426 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10427 #endif
10428 }
10429 return resultobj;
10430 fail:
10431 return NULL;
10432 }
10433
10434
10435 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
10436 PyObject *resultobj;
10437 wxFont *arg1 = (wxFont *) 0 ;
10438 wxString result;
10439 PyObject * obj0 = 0 ;
10440 char *kwnames[] = {
10441 (char *) "self", NULL
10442 };
10443
10444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
10445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10446 if (SWIG_arg_fail(1)) SWIG_fail;
10447 {
10448 PyThreadState* __tstate = wxPyBeginAllowThreads();
10449 result = ((wxFont const *)arg1)->GetWeightString();
10450
10451 wxPyEndAllowThreads(__tstate);
10452 if (PyErr_Occurred()) SWIG_fail;
10453 }
10454 {
10455 #if wxUSE_UNICODE
10456 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10457 #else
10458 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10459 #endif
10460 }
10461 return resultobj;
10462 fail:
10463 return NULL;
10464 }
10465
10466
10467 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10468 PyObject *resultobj;
10469 wxFont *arg1 = (wxFont *) 0 ;
10470 bool arg2 = (bool) true ;
10471 PyObject * obj0 = 0 ;
10472 PyObject * obj1 = 0 ;
10473 char *kwnames[] = {
10474 (char *) "self",(char *) "no", NULL
10475 };
10476
10477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
10478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10479 if (SWIG_arg_fail(1)) SWIG_fail;
10480 if (obj1) {
10481 {
10482 arg2 = (bool)(SWIG_As_bool(obj1));
10483 if (SWIG_arg_fail(2)) SWIG_fail;
10484 }
10485 }
10486 {
10487 PyThreadState* __tstate = wxPyBeginAllowThreads();
10488 (arg1)->SetNoAntiAliasing(arg2);
10489
10490 wxPyEndAllowThreads(__tstate);
10491 if (PyErr_Occurred()) SWIG_fail;
10492 }
10493 Py_INCREF(Py_None); resultobj = Py_None;
10494 return resultobj;
10495 fail:
10496 return NULL;
10497 }
10498
10499
10500 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10501 PyObject *resultobj;
10502 wxFont *arg1 = (wxFont *) 0 ;
10503 bool result;
10504 PyObject * obj0 = 0 ;
10505 char *kwnames[] = {
10506 (char *) "self", NULL
10507 };
10508
10509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
10510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10511 if (SWIG_arg_fail(1)) SWIG_fail;
10512 {
10513 PyThreadState* __tstate = wxPyBeginAllowThreads();
10514 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
10515
10516 wxPyEndAllowThreads(__tstate);
10517 if (PyErr_Occurred()) SWIG_fail;
10518 }
10519 {
10520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10521 }
10522 return resultobj;
10523 fail:
10524 return NULL;
10525 }
10526
10527
10528 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10529 PyObject *resultobj;
10530 wxFontEncoding result;
10531 char *kwnames[] = {
10532 NULL
10533 };
10534
10535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
10536 {
10537 if (!wxPyCheckForApp()) SWIG_fail;
10538 PyThreadState* __tstate = wxPyBeginAllowThreads();
10539 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
10540
10541 wxPyEndAllowThreads(__tstate);
10542 if (PyErr_Occurred()) SWIG_fail;
10543 }
10544 resultobj = SWIG_From_int((result));
10545 return resultobj;
10546 fail:
10547 return NULL;
10548 }
10549
10550
10551 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10552 PyObject *resultobj;
10553 wxFontEncoding arg1 ;
10554 PyObject * obj0 = 0 ;
10555 char *kwnames[] = {
10556 (char *) "encoding", NULL
10557 };
10558
10559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
10560 {
10561 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
10562 if (SWIG_arg_fail(1)) SWIG_fail;
10563 }
10564 {
10565 if (!wxPyCheckForApp()) SWIG_fail;
10566 PyThreadState* __tstate = wxPyBeginAllowThreads();
10567 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
10568
10569 wxPyEndAllowThreads(__tstate);
10570 if (PyErr_Occurred()) SWIG_fail;
10571 }
10572 Py_INCREF(Py_None); resultobj = Py_None;
10573 return resultobj;
10574 fail:
10575 return NULL;
10576 }
10577
10578
10579 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
10580 PyObject *obj;
10581 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10582 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
10583 Py_INCREF(obj);
10584 return Py_BuildValue((char *)"");
10585 }
10586 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10587 PyObject *resultobj;
10588 wxPyFontEnumerator *result;
10589 char *kwnames[] = {
10590 NULL
10591 };
10592
10593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
10594 {
10595 if (!wxPyCheckForApp()) SWIG_fail;
10596 PyThreadState* __tstate = wxPyBeginAllowThreads();
10597 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
10598
10599 wxPyEndAllowThreads(__tstate);
10600 if (PyErr_Occurred()) SWIG_fail;
10601 }
10602 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
10603 return resultobj;
10604 fail:
10605 return NULL;
10606 }
10607
10608
10609 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10610 PyObject *resultobj;
10611 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10612 PyObject * obj0 = 0 ;
10613 char *kwnames[] = {
10614 (char *) "self", NULL
10615 };
10616
10617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
10618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10619 if (SWIG_arg_fail(1)) SWIG_fail;
10620 {
10621 PyThreadState* __tstate = wxPyBeginAllowThreads();
10622 delete arg1;
10623
10624 wxPyEndAllowThreads(__tstate);
10625 if (PyErr_Occurred()) SWIG_fail;
10626 }
10627 Py_INCREF(Py_None); resultobj = Py_None;
10628 return resultobj;
10629 fail:
10630 return NULL;
10631 }
10632
10633
10634 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10635 PyObject *resultobj;
10636 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10637 PyObject *arg2 = (PyObject *) 0 ;
10638 PyObject *arg3 = (PyObject *) 0 ;
10639 bool arg4 ;
10640 PyObject * obj0 = 0 ;
10641 PyObject * obj1 = 0 ;
10642 PyObject * obj2 = 0 ;
10643 PyObject * obj3 = 0 ;
10644 char *kwnames[] = {
10645 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10646 };
10647
10648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10650 if (SWIG_arg_fail(1)) SWIG_fail;
10651 arg2 = obj1;
10652 arg3 = obj2;
10653 {
10654 arg4 = (bool)(SWIG_As_bool(obj3));
10655 if (SWIG_arg_fail(4)) SWIG_fail;
10656 }
10657 {
10658 PyThreadState* __tstate = wxPyBeginAllowThreads();
10659 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10660
10661 wxPyEndAllowThreads(__tstate);
10662 if (PyErr_Occurred()) SWIG_fail;
10663 }
10664 Py_INCREF(Py_None); resultobj = Py_None;
10665 return resultobj;
10666 fail:
10667 return NULL;
10668 }
10669
10670
10671 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10672 PyObject *resultobj;
10673 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10674 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
10675 bool arg3 = (bool) false ;
10676 bool result;
10677 PyObject * obj0 = 0 ;
10678 PyObject * obj1 = 0 ;
10679 PyObject * obj2 = 0 ;
10680 char *kwnames[] = {
10681 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
10682 };
10683
10684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
10685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10686 if (SWIG_arg_fail(1)) SWIG_fail;
10687 if (obj1) {
10688 {
10689 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10690 if (SWIG_arg_fail(2)) SWIG_fail;
10691 }
10692 }
10693 if (obj2) {
10694 {
10695 arg3 = (bool)(SWIG_As_bool(obj2));
10696 if (SWIG_arg_fail(3)) SWIG_fail;
10697 }
10698 }
10699 {
10700 PyThreadState* __tstate = wxPyBeginAllowThreads();
10701 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
10702
10703 wxPyEndAllowThreads(__tstate);
10704 if (PyErr_Occurred()) SWIG_fail;
10705 }
10706 {
10707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10708 }
10709 return resultobj;
10710 fail:
10711 return NULL;
10712 }
10713
10714
10715 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10716 PyObject *resultobj;
10717 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10718 wxString const &arg2_defvalue = wxPyEmptyString ;
10719 wxString *arg2 = (wxString *) &arg2_defvalue ;
10720 bool result;
10721 bool temp2 = false ;
10722 PyObject * obj0 = 0 ;
10723 PyObject * obj1 = 0 ;
10724 char *kwnames[] = {
10725 (char *) "self",(char *) "facename", NULL
10726 };
10727
10728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
10729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10730 if (SWIG_arg_fail(1)) SWIG_fail;
10731 if (obj1) {
10732 {
10733 arg2 = wxString_in_helper(obj1);
10734 if (arg2 == NULL) SWIG_fail;
10735 temp2 = true;
10736 }
10737 }
10738 {
10739 PyThreadState* __tstate = wxPyBeginAllowThreads();
10740 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
10741
10742 wxPyEndAllowThreads(__tstate);
10743 if (PyErr_Occurred()) SWIG_fail;
10744 }
10745 {
10746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10747 }
10748 {
10749 if (temp2)
10750 delete arg2;
10751 }
10752 return resultobj;
10753 fail:
10754 {
10755 if (temp2)
10756 delete arg2;
10757 }
10758 return NULL;
10759 }
10760
10761
10762 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10763 PyObject *resultobj;
10764 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10765 PyObject *result;
10766 PyObject * obj0 = 0 ;
10767 char *kwnames[] = {
10768 (char *) "self", NULL
10769 };
10770
10771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
10772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10773 if (SWIG_arg_fail(1)) SWIG_fail;
10774 {
10775 PyThreadState* __tstate = wxPyBeginAllowThreads();
10776 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
10777
10778 wxPyEndAllowThreads(__tstate);
10779 if (PyErr_Occurred()) SWIG_fail;
10780 }
10781 resultobj = result;
10782 return resultobj;
10783 fail:
10784 return NULL;
10785 }
10786
10787
10788 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10789 PyObject *resultobj;
10790 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10791 PyObject *result;
10792 PyObject * obj0 = 0 ;
10793 char *kwnames[] = {
10794 (char *) "self", NULL
10795 };
10796
10797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
10798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10799 if (SWIG_arg_fail(1)) SWIG_fail;
10800 {
10801 PyThreadState* __tstate = wxPyBeginAllowThreads();
10802 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
10803
10804 wxPyEndAllowThreads(__tstate);
10805 if (PyErr_Occurred()) SWIG_fail;
10806 }
10807 resultobj = result;
10808 return resultobj;
10809 fail:
10810 return NULL;
10811 }
10812
10813
10814 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
10815 PyObject *obj;
10816 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10817 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
10818 Py_INCREF(obj);
10819 return Py_BuildValue((char *)"");
10820 }
10821 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
10822 PyObject *resultobj;
10823 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10824 int arg2 ;
10825 PyObject * obj0 = 0 ;
10826 PyObject * obj1 = 0 ;
10827 char *kwnames[] = {
10828 (char *) "self",(char *) "Language", NULL
10829 };
10830
10831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
10832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10833 if (SWIG_arg_fail(1)) SWIG_fail;
10834 {
10835 arg2 = (int)(SWIG_As_int(obj1));
10836 if (SWIG_arg_fail(2)) SWIG_fail;
10837 }
10838 if (arg1) (arg1)->Language = arg2;
10839
10840 Py_INCREF(Py_None); resultobj = Py_None;
10841 return resultobj;
10842 fail:
10843 return NULL;
10844 }
10845
10846
10847 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
10848 PyObject *resultobj;
10849 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10850 int result;
10851 PyObject * obj0 = 0 ;
10852 char *kwnames[] = {
10853 (char *) "self", NULL
10854 };
10855
10856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
10857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10858 if (SWIG_arg_fail(1)) SWIG_fail;
10859 result = (int) ((arg1)->Language);
10860
10861 {
10862 resultobj = SWIG_From_int((int)(result));
10863 }
10864 return resultobj;
10865 fail:
10866 return NULL;
10867 }
10868
10869
10870 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
10871 PyObject *resultobj;
10872 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10873 wxString *arg2 = (wxString *) 0 ;
10874 bool temp2 = false ;
10875 PyObject * obj0 = 0 ;
10876 PyObject * obj1 = 0 ;
10877 char *kwnames[] = {
10878 (char *) "self",(char *) "CanonicalName", NULL
10879 };
10880
10881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
10882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10883 if (SWIG_arg_fail(1)) SWIG_fail;
10884 {
10885 arg2 = wxString_in_helper(obj1);
10886 if (arg2 == NULL) SWIG_fail;
10887 temp2 = true;
10888 }
10889 if (arg1) (arg1)->CanonicalName = *arg2;
10890
10891 Py_INCREF(Py_None); resultobj = Py_None;
10892 {
10893 if (temp2)
10894 delete arg2;
10895 }
10896 return resultobj;
10897 fail:
10898 {
10899 if (temp2)
10900 delete arg2;
10901 }
10902 return NULL;
10903 }
10904
10905
10906 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
10907 PyObject *resultobj;
10908 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10909 wxString *result;
10910 PyObject * obj0 = 0 ;
10911 char *kwnames[] = {
10912 (char *) "self", NULL
10913 };
10914
10915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
10916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10917 if (SWIG_arg_fail(1)) SWIG_fail;
10918 result = (wxString *)& ((arg1)->CanonicalName);
10919
10920 {
10921 #if wxUSE_UNICODE
10922 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10923 #else
10924 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10925 #endif
10926 }
10927 return resultobj;
10928 fail:
10929 return NULL;
10930 }
10931
10932
10933 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
10934 PyObject *resultobj;
10935 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10936 wxString *arg2 = (wxString *) 0 ;
10937 bool temp2 = false ;
10938 PyObject * obj0 = 0 ;
10939 PyObject * obj1 = 0 ;
10940 char *kwnames[] = {
10941 (char *) "self",(char *) "Description", NULL
10942 };
10943
10944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
10945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10946 if (SWIG_arg_fail(1)) SWIG_fail;
10947 {
10948 arg2 = wxString_in_helper(obj1);
10949 if (arg2 == NULL) SWIG_fail;
10950 temp2 = true;
10951 }
10952 if (arg1) (arg1)->Description = *arg2;
10953
10954 Py_INCREF(Py_None); resultobj = Py_None;
10955 {
10956 if (temp2)
10957 delete arg2;
10958 }
10959 return resultobj;
10960 fail:
10961 {
10962 if (temp2)
10963 delete arg2;
10964 }
10965 return NULL;
10966 }
10967
10968
10969 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
10970 PyObject *resultobj;
10971 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10972 wxString *result;
10973 PyObject * obj0 = 0 ;
10974 char *kwnames[] = {
10975 (char *) "self", NULL
10976 };
10977
10978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
10979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10980 if (SWIG_arg_fail(1)) SWIG_fail;
10981 result = (wxString *)& ((arg1)->Description);
10982
10983 {
10984 #if wxUSE_UNICODE
10985 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10986 #else
10987 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10988 #endif
10989 }
10990 return resultobj;
10991 fail:
10992 return NULL;
10993 }
10994
10995
10996 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
10997 PyObject *obj;
10998 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10999 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
11000 Py_INCREF(obj);
11001 return Py_BuildValue((char *)"");
11002 }
11003 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11004 PyObject *resultobj;
11005 int arg1 = (int) -1 ;
11006 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11007 wxLocale *result;
11008 PyObject * obj0 = 0 ;
11009 PyObject * obj1 = 0 ;
11010 char *kwnames[] = {
11011 (char *) "language",(char *) "flags", NULL
11012 };
11013
11014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
11015 if (obj0) {
11016 {
11017 arg1 = (int)(SWIG_As_int(obj0));
11018 if (SWIG_arg_fail(1)) SWIG_fail;
11019 }
11020 }
11021 if (obj1) {
11022 {
11023 arg2 = (int)(SWIG_As_int(obj1));
11024 if (SWIG_arg_fail(2)) SWIG_fail;
11025 }
11026 }
11027 {
11028 PyThreadState* __tstate = wxPyBeginAllowThreads();
11029 result = (wxLocale *)new_wxLocale(arg1,arg2);
11030
11031 wxPyEndAllowThreads(__tstate);
11032 if (PyErr_Occurred()) SWIG_fail;
11033 }
11034 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11035 return resultobj;
11036 fail:
11037 return NULL;
11038 }
11039
11040
11041 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11042 PyObject *resultobj;
11043 wxLocale *arg1 = (wxLocale *) 0 ;
11044 PyObject * obj0 = 0 ;
11045 char *kwnames[] = {
11046 (char *) "self", NULL
11047 };
11048
11049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11051 if (SWIG_arg_fail(1)) SWIG_fail;
11052 {
11053 PyThreadState* __tstate = wxPyBeginAllowThreads();
11054 delete arg1;
11055
11056 wxPyEndAllowThreads(__tstate);
11057 if (PyErr_Occurred()) SWIG_fail;
11058 }
11059 Py_INCREF(Py_None); resultobj = Py_None;
11060 return resultobj;
11061 fail:
11062 return NULL;
11063 }
11064
11065
11066 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11067 PyObject *resultobj;
11068 wxLocale *arg1 = (wxLocale *) 0 ;
11069 wxString *arg2 = 0 ;
11070 wxString const &arg3_defvalue = wxPyEmptyString ;
11071 wxString *arg3 = (wxString *) &arg3_defvalue ;
11072 wxString const &arg4_defvalue = wxPyEmptyString ;
11073 wxString *arg4 = (wxString *) &arg4_defvalue ;
11074 bool arg5 = (bool) true ;
11075 bool arg6 = (bool) false ;
11076 bool result;
11077 bool temp2 = false ;
11078 bool temp3 = false ;
11079 bool temp4 = false ;
11080 PyObject * obj0 = 0 ;
11081 PyObject * obj1 = 0 ;
11082 PyObject * obj2 = 0 ;
11083 PyObject * obj3 = 0 ;
11084 PyObject * obj4 = 0 ;
11085 PyObject * obj5 = 0 ;
11086 char *kwnames[] = {
11087 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11088 };
11089
11090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11092 if (SWIG_arg_fail(1)) SWIG_fail;
11093 {
11094 arg2 = wxString_in_helper(obj1);
11095 if (arg2 == NULL) SWIG_fail;
11096 temp2 = true;
11097 }
11098 if (obj2) {
11099 {
11100 arg3 = wxString_in_helper(obj2);
11101 if (arg3 == NULL) SWIG_fail;
11102 temp3 = true;
11103 }
11104 }
11105 if (obj3) {
11106 {
11107 arg4 = wxString_in_helper(obj3);
11108 if (arg4 == NULL) SWIG_fail;
11109 temp4 = true;
11110 }
11111 }
11112 if (obj4) {
11113 {
11114 arg5 = (bool)(SWIG_As_bool(obj4));
11115 if (SWIG_arg_fail(5)) SWIG_fail;
11116 }
11117 }
11118 if (obj5) {
11119 {
11120 arg6 = (bool)(SWIG_As_bool(obj5));
11121 if (SWIG_arg_fail(6)) SWIG_fail;
11122 }
11123 }
11124 {
11125 PyThreadState* __tstate = wxPyBeginAllowThreads();
11126 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11127
11128 wxPyEndAllowThreads(__tstate);
11129 if (PyErr_Occurred()) SWIG_fail;
11130 }
11131 {
11132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11133 }
11134 {
11135 if (temp2)
11136 delete arg2;
11137 }
11138 {
11139 if (temp3)
11140 delete arg3;
11141 }
11142 {
11143 if (temp4)
11144 delete arg4;
11145 }
11146 return resultobj;
11147 fail:
11148 {
11149 if (temp2)
11150 delete arg2;
11151 }
11152 {
11153 if (temp3)
11154 delete arg3;
11155 }
11156 {
11157 if (temp4)
11158 delete arg4;
11159 }
11160 return NULL;
11161 }
11162
11163
11164 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11165 PyObject *resultobj;
11166 wxLocale *arg1 = (wxLocale *) 0 ;
11167 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11168 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11169 bool result;
11170 PyObject * obj0 = 0 ;
11171 PyObject * obj1 = 0 ;
11172 PyObject * obj2 = 0 ;
11173 char *kwnames[] = {
11174 (char *) "self",(char *) "language",(char *) "flags", NULL
11175 };
11176
11177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11179 if (SWIG_arg_fail(1)) SWIG_fail;
11180 if (obj1) {
11181 {
11182 arg2 = (int)(SWIG_As_int(obj1));
11183 if (SWIG_arg_fail(2)) SWIG_fail;
11184 }
11185 }
11186 if (obj2) {
11187 {
11188 arg3 = (int)(SWIG_As_int(obj2));
11189 if (SWIG_arg_fail(3)) SWIG_fail;
11190 }
11191 }
11192 {
11193 PyThreadState* __tstate = wxPyBeginAllowThreads();
11194 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11195
11196 wxPyEndAllowThreads(__tstate);
11197 if (PyErr_Occurred()) SWIG_fail;
11198 }
11199 {
11200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11201 }
11202 return resultobj;
11203 fail:
11204 return NULL;
11205 }
11206
11207
11208 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11209 PyObject *resultobj;
11210 int result;
11211 char *kwnames[] = {
11212 NULL
11213 };
11214
11215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11216 {
11217 PyThreadState* __tstate = wxPyBeginAllowThreads();
11218 result = (int)wxLocale::GetSystemLanguage();
11219
11220 wxPyEndAllowThreads(__tstate);
11221 if (PyErr_Occurred()) SWIG_fail;
11222 }
11223 {
11224 resultobj = SWIG_From_int((int)(result));
11225 }
11226 return resultobj;
11227 fail:
11228 return NULL;
11229 }
11230
11231
11232 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11233 PyObject *resultobj;
11234 wxFontEncoding result;
11235 char *kwnames[] = {
11236 NULL
11237 };
11238
11239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11240 {
11241 PyThreadState* __tstate = wxPyBeginAllowThreads();
11242 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11243
11244 wxPyEndAllowThreads(__tstate);
11245 if (PyErr_Occurred()) SWIG_fail;
11246 }
11247 resultobj = SWIG_From_int((result));
11248 return resultobj;
11249 fail:
11250 return NULL;
11251 }
11252
11253
11254 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11255 PyObject *resultobj;
11256 wxString result;
11257 char *kwnames[] = {
11258 NULL
11259 };
11260
11261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11262 {
11263 PyThreadState* __tstate = wxPyBeginAllowThreads();
11264 result = wxLocale::GetSystemEncodingName();
11265
11266 wxPyEndAllowThreads(__tstate);
11267 if (PyErr_Occurred()) SWIG_fail;
11268 }
11269 {
11270 #if wxUSE_UNICODE
11271 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11272 #else
11273 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11274 #endif
11275 }
11276 return resultobj;
11277 fail:
11278 return NULL;
11279 }
11280
11281
11282 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11283 PyObject *resultobj;
11284 wxLocale *arg1 = (wxLocale *) 0 ;
11285 bool result;
11286 PyObject * obj0 = 0 ;
11287 char *kwnames[] = {
11288 (char *) "self", NULL
11289 };
11290
11291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11293 if (SWIG_arg_fail(1)) SWIG_fail;
11294 {
11295 PyThreadState* __tstate = wxPyBeginAllowThreads();
11296 result = (bool)((wxLocale const *)arg1)->IsOk();
11297
11298 wxPyEndAllowThreads(__tstate);
11299 if (PyErr_Occurred()) SWIG_fail;
11300 }
11301 {
11302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11303 }
11304 return resultobj;
11305 fail:
11306 return NULL;
11307 }
11308
11309
11310 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11311 PyObject *resultobj;
11312 wxLocale *arg1 = (wxLocale *) 0 ;
11313 wxString result;
11314 PyObject * obj0 = 0 ;
11315 char *kwnames[] = {
11316 (char *) "self", NULL
11317 };
11318
11319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11321 if (SWIG_arg_fail(1)) SWIG_fail;
11322 {
11323 PyThreadState* __tstate = wxPyBeginAllowThreads();
11324 result = ((wxLocale const *)arg1)->GetLocale();
11325
11326 wxPyEndAllowThreads(__tstate);
11327 if (PyErr_Occurred()) SWIG_fail;
11328 }
11329 {
11330 #if wxUSE_UNICODE
11331 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11332 #else
11333 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11334 #endif
11335 }
11336 return resultobj;
11337 fail:
11338 return NULL;
11339 }
11340
11341
11342 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11343 PyObject *resultobj;
11344 wxLocale *arg1 = (wxLocale *) 0 ;
11345 int result;
11346 PyObject * obj0 = 0 ;
11347 char *kwnames[] = {
11348 (char *) "self", NULL
11349 };
11350
11351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
11352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11353 if (SWIG_arg_fail(1)) SWIG_fail;
11354 {
11355 PyThreadState* __tstate = wxPyBeginAllowThreads();
11356 result = (int)((wxLocale const *)arg1)->GetLanguage();
11357
11358 wxPyEndAllowThreads(__tstate);
11359 if (PyErr_Occurred()) SWIG_fail;
11360 }
11361 {
11362 resultobj = SWIG_From_int((int)(result));
11363 }
11364 return resultobj;
11365 fail:
11366 return NULL;
11367 }
11368
11369
11370 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
11371 PyObject *resultobj;
11372 wxLocale *arg1 = (wxLocale *) 0 ;
11373 wxString result;
11374 PyObject * obj0 = 0 ;
11375 char *kwnames[] = {
11376 (char *) "self", NULL
11377 };
11378
11379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
11380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11381 if (SWIG_arg_fail(1)) SWIG_fail;
11382 {
11383 PyThreadState* __tstate = wxPyBeginAllowThreads();
11384 result = ((wxLocale const *)arg1)->GetSysName();
11385
11386 wxPyEndAllowThreads(__tstate);
11387 if (PyErr_Occurred()) SWIG_fail;
11388 }
11389 {
11390 #if wxUSE_UNICODE
11391 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11392 #else
11393 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11394 #endif
11395 }
11396 return resultobj;
11397 fail:
11398 return NULL;
11399 }
11400
11401
11402 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
11403 PyObject *resultobj;
11404 wxLocale *arg1 = (wxLocale *) 0 ;
11405 wxString result;
11406 PyObject * obj0 = 0 ;
11407 char *kwnames[] = {
11408 (char *) "self", NULL
11409 };
11410
11411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
11412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11413 if (SWIG_arg_fail(1)) SWIG_fail;
11414 {
11415 PyThreadState* __tstate = wxPyBeginAllowThreads();
11416 result = ((wxLocale const *)arg1)->GetCanonicalName();
11417
11418 wxPyEndAllowThreads(__tstate);
11419 if (PyErr_Occurred()) SWIG_fail;
11420 }
11421 {
11422 #if wxUSE_UNICODE
11423 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11424 #else
11425 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11426 #endif
11427 }
11428 return resultobj;
11429 fail:
11430 return NULL;
11431 }
11432
11433
11434 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
11435 PyObject *resultobj;
11436 wxString *arg1 = 0 ;
11437 bool temp1 = false ;
11438 PyObject * obj0 = 0 ;
11439 char *kwnames[] = {
11440 (char *) "prefix", NULL
11441 };
11442
11443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
11444 {
11445 arg1 = wxString_in_helper(obj0);
11446 if (arg1 == NULL) SWIG_fail;
11447 temp1 = true;
11448 }
11449 {
11450 PyThreadState* __tstate = wxPyBeginAllowThreads();
11451 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
11452
11453 wxPyEndAllowThreads(__tstate);
11454 if (PyErr_Occurred()) SWIG_fail;
11455 }
11456 Py_INCREF(Py_None); resultobj = Py_None;
11457 {
11458 if (temp1)
11459 delete arg1;
11460 }
11461 return resultobj;
11462 fail:
11463 {
11464 if (temp1)
11465 delete arg1;
11466 }
11467 return NULL;
11468 }
11469
11470
11471 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
11472 PyObject *resultobj;
11473 wxLocale *arg1 = (wxLocale *) 0 ;
11474 wxString *arg2 = 0 ;
11475 bool result;
11476 bool temp2 = false ;
11477 PyObject * obj0 = 0 ;
11478 PyObject * obj1 = 0 ;
11479 char *kwnames[] = {
11480 (char *) "self",(char *) "szDomain", NULL
11481 };
11482
11483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
11484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11485 if (SWIG_arg_fail(1)) SWIG_fail;
11486 {
11487 arg2 = wxString_in_helper(obj1);
11488 if (arg2 == NULL) SWIG_fail;
11489 temp2 = true;
11490 }
11491 {
11492 PyThreadState* __tstate = wxPyBeginAllowThreads();
11493 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
11494
11495 wxPyEndAllowThreads(__tstate);
11496 if (PyErr_Occurred()) SWIG_fail;
11497 }
11498 {
11499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11500 }
11501 {
11502 if (temp2)
11503 delete arg2;
11504 }
11505 return resultobj;
11506 fail:
11507 {
11508 if (temp2)
11509 delete arg2;
11510 }
11511 return NULL;
11512 }
11513
11514
11515 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
11516 PyObject *resultobj;
11517 wxLocale *arg1 = (wxLocale *) 0 ;
11518 wxString *arg2 = 0 ;
11519 bool result;
11520 bool temp2 = false ;
11521 PyObject * obj0 = 0 ;
11522 PyObject * obj1 = 0 ;
11523 char *kwnames[] = {
11524 (char *) "self",(char *) "szDomain", NULL
11525 };
11526
11527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
11528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11529 if (SWIG_arg_fail(1)) SWIG_fail;
11530 {
11531 arg2 = wxString_in_helper(obj1);
11532 if (arg2 == NULL) SWIG_fail;
11533 temp2 = true;
11534 }
11535 {
11536 PyThreadState* __tstate = wxPyBeginAllowThreads();
11537 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
11538
11539 wxPyEndAllowThreads(__tstate);
11540 if (PyErr_Occurred()) SWIG_fail;
11541 }
11542 {
11543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11544 }
11545 {
11546 if (temp2)
11547 delete arg2;
11548 }
11549 return resultobj;
11550 fail:
11551 {
11552 if (temp2)
11553 delete arg2;
11554 }
11555 return NULL;
11556 }
11557
11558
11559 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11560 PyObject *resultobj;
11561 int arg1 ;
11562 wxLanguageInfo *result;
11563 PyObject * obj0 = 0 ;
11564 char *kwnames[] = {
11565 (char *) "lang", NULL
11566 };
11567
11568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
11569 {
11570 arg1 = (int)(SWIG_As_int(obj0));
11571 if (SWIG_arg_fail(1)) SWIG_fail;
11572 }
11573 {
11574 PyThreadState* __tstate = wxPyBeginAllowThreads();
11575 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
11576
11577 wxPyEndAllowThreads(__tstate);
11578 if (PyErr_Occurred()) SWIG_fail;
11579 }
11580 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11581 return resultobj;
11582 fail:
11583 return NULL;
11584 }
11585
11586
11587 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
11588 PyObject *resultobj;
11589 int arg1 ;
11590 wxString result;
11591 PyObject * obj0 = 0 ;
11592 char *kwnames[] = {
11593 (char *) "lang", NULL
11594 };
11595
11596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
11597 {
11598 arg1 = (int)(SWIG_As_int(obj0));
11599 if (SWIG_arg_fail(1)) SWIG_fail;
11600 }
11601 {
11602 PyThreadState* __tstate = wxPyBeginAllowThreads();
11603 result = wxLocale::GetLanguageName(arg1);
11604
11605 wxPyEndAllowThreads(__tstate);
11606 if (PyErr_Occurred()) SWIG_fail;
11607 }
11608 {
11609 #if wxUSE_UNICODE
11610 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11611 #else
11612 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11613 #endif
11614 }
11615 return resultobj;
11616 fail:
11617 return NULL;
11618 }
11619
11620
11621 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11622 PyObject *resultobj;
11623 wxString *arg1 = 0 ;
11624 wxLanguageInfo *result;
11625 bool temp1 = false ;
11626 PyObject * obj0 = 0 ;
11627 char *kwnames[] = {
11628 (char *) "locale", NULL
11629 };
11630
11631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
11632 {
11633 arg1 = wxString_in_helper(obj0);
11634 if (arg1 == NULL) SWIG_fail;
11635 temp1 = true;
11636 }
11637 {
11638 PyThreadState* __tstate = wxPyBeginAllowThreads();
11639 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
11640
11641 wxPyEndAllowThreads(__tstate);
11642 if (PyErr_Occurred()) SWIG_fail;
11643 }
11644 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11645 {
11646 if (temp1)
11647 delete arg1;
11648 }
11649 return resultobj;
11650 fail:
11651 {
11652 if (temp1)
11653 delete arg1;
11654 }
11655 return NULL;
11656 }
11657
11658
11659 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11660 PyObject *resultobj;
11661 wxLanguageInfo *arg1 = 0 ;
11662 PyObject * obj0 = 0 ;
11663 char *kwnames[] = {
11664 (char *) "info", NULL
11665 };
11666
11667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
11668 {
11669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11670 if (SWIG_arg_fail(1)) SWIG_fail;
11671 if (arg1 == NULL) {
11672 SWIG_null_ref("wxLanguageInfo");
11673 }
11674 if (SWIG_arg_fail(1)) SWIG_fail;
11675 }
11676 {
11677 PyThreadState* __tstate = wxPyBeginAllowThreads();
11678 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
11679
11680 wxPyEndAllowThreads(__tstate);
11681 if (PyErr_Occurred()) SWIG_fail;
11682 }
11683 Py_INCREF(Py_None); resultobj = Py_None;
11684 return resultobj;
11685 fail:
11686 return NULL;
11687 }
11688
11689
11690 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
11691 PyObject *resultobj;
11692 wxLocale *arg1 = (wxLocale *) 0 ;
11693 wxString *arg2 = 0 ;
11694 wxString const &arg3_defvalue = wxPyEmptyString ;
11695 wxString *arg3 = (wxString *) &arg3_defvalue ;
11696 wxString result;
11697 bool temp2 = false ;
11698 bool temp3 = false ;
11699 PyObject * obj0 = 0 ;
11700 PyObject * obj1 = 0 ;
11701 PyObject * obj2 = 0 ;
11702 char *kwnames[] = {
11703 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
11704 };
11705
11706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
11707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11708 if (SWIG_arg_fail(1)) SWIG_fail;
11709 {
11710 arg2 = wxString_in_helper(obj1);
11711 if (arg2 == NULL) SWIG_fail;
11712 temp2 = true;
11713 }
11714 if (obj2) {
11715 {
11716 arg3 = wxString_in_helper(obj2);
11717 if (arg3 == NULL) SWIG_fail;
11718 temp3 = true;
11719 }
11720 }
11721 {
11722 PyThreadState* __tstate = wxPyBeginAllowThreads();
11723 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
11724
11725 wxPyEndAllowThreads(__tstate);
11726 if (PyErr_Occurred()) SWIG_fail;
11727 }
11728 {
11729 #if wxUSE_UNICODE
11730 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11731 #else
11732 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11733 #endif
11734 }
11735 {
11736 if (temp2)
11737 delete arg2;
11738 }
11739 {
11740 if (temp3)
11741 delete arg3;
11742 }
11743 return resultobj;
11744 fail:
11745 {
11746 if (temp2)
11747 delete arg2;
11748 }
11749 {
11750 if (temp3)
11751 delete arg3;
11752 }
11753 return NULL;
11754 }
11755
11756
11757 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
11758 PyObject *resultobj;
11759 wxLocale *arg1 = (wxLocale *) 0 ;
11760 wxString *result;
11761 PyObject * obj0 = 0 ;
11762 char *kwnames[] = {
11763 (char *) "self", NULL
11764 };
11765
11766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
11767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11768 if (SWIG_arg_fail(1)) SWIG_fail;
11769 {
11770 PyThreadState* __tstate = wxPyBeginAllowThreads();
11771 {
11772 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
11773 result = (wxString *) &_result_ref;
11774 }
11775
11776 wxPyEndAllowThreads(__tstate);
11777 if (PyErr_Occurred()) SWIG_fail;
11778 }
11779 {
11780 #if wxUSE_UNICODE
11781 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11782 #else
11783 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11784 #endif
11785 }
11786 return resultobj;
11787 fail:
11788 return NULL;
11789 }
11790
11791
11792 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
11793 PyObject *obj;
11794 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11795 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
11796 Py_INCREF(obj);
11797 return Py_BuildValue((char *)"");
11798 }
11799 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11800 PyObject *resultobj;
11801 wxLocale *result;
11802 char *kwnames[] = {
11803 NULL
11804 };
11805
11806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
11807 {
11808 PyThreadState* __tstate = wxPyBeginAllowThreads();
11809 result = (wxLocale *)wxGetLocale();
11810
11811 wxPyEndAllowThreads(__tstate);
11812 if (PyErr_Occurred()) SWIG_fail;
11813 }
11814 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
11815 return resultobj;
11816 fail:
11817 return NULL;
11818 }
11819
11820
11821 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
11822 PyObject *resultobj;
11823 wxString *arg1 = 0 ;
11824 wxString result;
11825 bool temp1 = false ;
11826 PyObject * obj0 = 0 ;
11827
11828 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
11829 {
11830 arg1 = wxString_in_helper(obj0);
11831 if (arg1 == NULL) SWIG_fail;
11832 temp1 = true;
11833 }
11834 {
11835 PyThreadState* __tstate = wxPyBeginAllowThreads();
11836 result = wxGetTranslation((wxString const &)*arg1);
11837
11838 wxPyEndAllowThreads(__tstate);
11839 if (PyErr_Occurred()) SWIG_fail;
11840 }
11841 {
11842 #if wxUSE_UNICODE
11843 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11844 #else
11845 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11846 #endif
11847 }
11848 {
11849 if (temp1)
11850 delete arg1;
11851 }
11852 return resultobj;
11853 fail:
11854 {
11855 if (temp1)
11856 delete arg1;
11857 }
11858 return NULL;
11859 }
11860
11861
11862 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
11863 PyObject *resultobj;
11864 wxString *arg1 = 0 ;
11865 wxString *arg2 = 0 ;
11866 size_t arg3 ;
11867 wxString result;
11868 bool temp1 = false ;
11869 bool temp2 = false ;
11870 PyObject * obj0 = 0 ;
11871 PyObject * obj1 = 0 ;
11872 PyObject * obj2 = 0 ;
11873
11874 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
11875 {
11876 arg1 = wxString_in_helper(obj0);
11877 if (arg1 == NULL) SWIG_fail;
11878 temp1 = true;
11879 }
11880 {
11881 arg2 = wxString_in_helper(obj1);
11882 if (arg2 == NULL) SWIG_fail;
11883 temp2 = true;
11884 }
11885 {
11886 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
11887 if (SWIG_arg_fail(3)) SWIG_fail;
11888 }
11889 {
11890 PyThreadState* __tstate = wxPyBeginAllowThreads();
11891 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11892
11893 wxPyEndAllowThreads(__tstate);
11894 if (PyErr_Occurred()) SWIG_fail;
11895 }
11896 {
11897 #if wxUSE_UNICODE
11898 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11899 #else
11900 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11901 #endif
11902 }
11903 {
11904 if (temp1)
11905 delete arg1;
11906 }
11907 {
11908 if (temp2)
11909 delete arg2;
11910 }
11911 return resultobj;
11912 fail:
11913 {
11914 if (temp1)
11915 delete arg1;
11916 }
11917 {
11918 if (temp2)
11919 delete arg2;
11920 }
11921 return NULL;
11922 }
11923
11924
11925 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
11926 int argc;
11927 PyObject *argv[4];
11928 int ii;
11929
11930 argc = PyObject_Length(args);
11931 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
11932 argv[ii] = PyTuple_GetItem(args,ii);
11933 }
11934 if (argc == 1) {
11935 int _v;
11936 {
11937 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11938 }
11939 if (_v) {
11940 return _wrap_GetTranslation__SWIG_0(self,args);
11941 }
11942 }
11943 if (argc == 3) {
11944 int _v;
11945 {
11946 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11947 }
11948 if (_v) {
11949 {
11950 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
11951 }
11952 if (_v) {
11953 _v = SWIG_Check_unsigned_SS_long(argv[2]);
11954 if (_v) {
11955 return _wrap_GetTranslation__SWIG_1(self,args);
11956 }
11957 }
11958 }
11959 }
11960
11961 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
11962 return NULL;
11963 }
11964
11965
11966 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
11967 PyObject *resultobj;
11968 wxEncodingConverter *result;
11969 char *kwnames[] = {
11970 NULL
11971 };
11972
11973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
11974 {
11975 PyThreadState* __tstate = wxPyBeginAllowThreads();
11976 result = (wxEncodingConverter *)new wxEncodingConverter();
11977
11978 wxPyEndAllowThreads(__tstate);
11979 if (PyErr_Occurred()) SWIG_fail;
11980 }
11981 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
11982 return resultobj;
11983 fail:
11984 return NULL;
11985 }
11986
11987
11988 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
11989 PyObject *resultobj;
11990 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
11991 PyObject * obj0 = 0 ;
11992 char *kwnames[] = {
11993 (char *) "self", NULL
11994 };
11995
11996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
11997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
11998 if (SWIG_arg_fail(1)) SWIG_fail;
11999 {
12000 PyThreadState* __tstate = wxPyBeginAllowThreads();
12001 delete arg1;
12002
12003 wxPyEndAllowThreads(__tstate);
12004 if (PyErr_Occurred()) SWIG_fail;
12005 }
12006 Py_INCREF(Py_None); resultobj = Py_None;
12007 return resultobj;
12008 fail:
12009 return NULL;
12010 }
12011
12012
12013 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
12014 PyObject *resultobj;
12015 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12016 wxFontEncoding arg2 ;
12017 wxFontEncoding arg3 ;
12018 int arg4 = (int) wxCONVERT_STRICT ;
12019 bool result;
12020 PyObject * obj0 = 0 ;
12021 PyObject * obj1 = 0 ;
12022 PyObject * obj2 = 0 ;
12023 PyObject * obj3 = 0 ;
12024 char *kwnames[] = {
12025 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
12026 };
12027
12028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12030 if (SWIG_arg_fail(1)) SWIG_fail;
12031 {
12032 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12033 if (SWIG_arg_fail(2)) SWIG_fail;
12034 }
12035 {
12036 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12037 if (SWIG_arg_fail(3)) SWIG_fail;
12038 }
12039 if (obj3) {
12040 {
12041 arg4 = (int)(SWIG_As_int(obj3));
12042 if (SWIG_arg_fail(4)) SWIG_fail;
12043 }
12044 }
12045 {
12046 PyThreadState* __tstate = wxPyBeginAllowThreads();
12047 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12048
12049 wxPyEndAllowThreads(__tstate);
12050 if (PyErr_Occurred()) SWIG_fail;
12051 }
12052 {
12053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12054 }
12055 return resultobj;
12056 fail:
12057 return NULL;
12058 }
12059
12060
12061 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12062 PyObject *resultobj;
12063 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12064 wxString *arg2 = 0 ;
12065 wxString result;
12066 bool temp2 = false ;
12067 PyObject * obj0 = 0 ;
12068 PyObject * obj1 = 0 ;
12069 char *kwnames[] = {
12070 (char *) "self",(char *) "input", NULL
12071 };
12072
12073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12075 if (SWIG_arg_fail(1)) SWIG_fail;
12076 {
12077 arg2 = wxString_in_helper(obj1);
12078 if (arg2 == NULL) SWIG_fail;
12079 temp2 = true;
12080 }
12081 {
12082 PyThreadState* __tstate = wxPyBeginAllowThreads();
12083 result = (arg1)->Convert((wxString const &)*arg2);
12084
12085 wxPyEndAllowThreads(__tstate);
12086 if (PyErr_Occurred()) SWIG_fail;
12087 }
12088 {
12089 #if wxUSE_UNICODE
12090 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12091 #else
12092 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12093 #endif
12094 }
12095 {
12096 if (temp2)
12097 delete arg2;
12098 }
12099 return resultobj;
12100 fail:
12101 {
12102 if (temp2)
12103 delete arg2;
12104 }
12105 return NULL;
12106 }
12107
12108
12109 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12110 PyObject *resultobj;
12111 wxFontEncoding arg1 ;
12112 int arg2 = (int) wxPLATFORM_CURRENT ;
12113 wxFontEncodingArray result;
12114 PyObject * obj0 = 0 ;
12115 PyObject * obj1 = 0 ;
12116 char *kwnames[] = {
12117 (char *) "enc",(char *) "platform", NULL
12118 };
12119
12120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12121 {
12122 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12123 if (SWIG_arg_fail(1)) SWIG_fail;
12124 }
12125 if (obj1) {
12126 {
12127 arg2 = (int)(SWIG_As_int(obj1));
12128 if (SWIG_arg_fail(2)) SWIG_fail;
12129 }
12130 }
12131 {
12132 PyThreadState* __tstate = wxPyBeginAllowThreads();
12133 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12134
12135 wxPyEndAllowThreads(__tstate);
12136 if (PyErr_Occurred()) SWIG_fail;
12137 }
12138 {
12139 resultobj = PyList_New(0);
12140 for (size_t i=0; i < (&result)->GetCount(); i++) {
12141 PyObject* number = PyInt_FromLong((&result)->Item(i));
12142 PyList_Append(resultobj, number);
12143 Py_DECREF(number);
12144 }
12145 }
12146 return resultobj;
12147 fail:
12148 return NULL;
12149 }
12150
12151
12152 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12153 PyObject *resultobj;
12154 wxFontEncoding arg1 ;
12155 wxFontEncodingArray result;
12156 PyObject * obj0 = 0 ;
12157 char *kwnames[] = {
12158 (char *) "enc", NULL
12159 };
12160
12161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12162 {
12163 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12164 if (SWIG_arg_fail(1)) SWIG_fail;
12165 }
12166 {
12167 PyThreadState* __tstate = wxPyBeginAllowThreads();
12168 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12169
12170 wxPyEndAllowThreads(__tstate);
12171 if (PyErr_Occurred()) SWIG_fail;
12172 }
12173 {
12174 resultobj = PyList_New(0);
12175 for (size_t i=0; i < (&result)->GetCount(); i++) {
12176 PyObject* number = PyInt_FromLong((&result)->Item(i));
12177 PyList_Append(resultobj, number);
12178 Py_DECREF(number);
12179 }
12180 }
12181 return resultobj;
12182 fail:
12183 return NULL;
12184 }
12185
12186
12187 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12188 PyObject *resultobj;
12189 wxFontEncoding arg1 ;
12190 wxFontEncoding arg2 ;
12191 bool result;
12192 PyObject * obj0 = 0 ;
12193 PyObject * obj1 = 0 ;
12194 char *kwnames[] = {
12195 (char *) "encIn",(char *) "encOut", NULL
12196 };
12197
12198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12199 {
12200 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12201 if (SWIG_arg_fail(1)) SWIG_fail;
12202 }
12203 {
12204 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12205 if (SWIG_arg_fail(2)) SWIG_fail;
12206 }
12207 {
12208 PyThreadState* __tstate = wxPyBeginAllowThreads();
12209 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12210
12211 wxPyEndAllowThreads(__tstate);
12212 if (PyErr_Occurred()) SWIG_fail;
12213 }
12214 {
12215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12216 }
12217 return resultobj;
12218 fail:
12219 return NULL;
12220 }
12221
12222
12223 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12224 PyObject *obj;
12225 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12226 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12227 Py_INCREF(obj);
12228 return Py_BuildValue((char *)"");
12229 }
12230 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12231 PyObject *resultobj;
12232 wxDC *arg1 = (wxDC *) 0 ;
12233 PyObject * obj0 = 0 ;
12234 char *kwnames[] = {
12235 (char *) "self", NULL
12236 };
12237
12238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12240 if (SWIG_arg_fail(1)) SWIG_fail;
12241 {
12242 PyThreadState* __tstate = wxPyBeginAllowThreads();
12243 delete arg1;
12244
12245 wxPyEndAllowThreads(__tstate);
12246 if (PyErr_Occurred()) SWIG_fail;
12247 }
12248 Py_INCREF(Py_None); resultobj = Py_None;
12249 return resultobj;
12250 fail:
12251 return NULL;
12252 }
12253
12254
12255 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12256 PyObject *resultobj;
12257 wxDC *arg1 = (wxDC *) 0 ;
12258 PyObject * obj0 = 0 ;
12259 char *kwnames[] = {
12260 (char *) "self", NULL
12261 };
12262
12263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12265 if (SWIG_arg_fail(1)) SWIG_fail;
12266 {
12267 PyThreadState* __tstate = wxPyBeginAllowThreads();
12268 (arg1)->BeginDrawing();
12269
12270 wxPyEndAllowThreads(__tstate);
12271 if (PyErr_Occurred()) SWIG_fail;
12272 }
12273 Py_INCREF(Py_None); resultobj = Py_None;
12274 return resultobj;
12275 fail:
12276 return NULL;
12277 }
12278
12279
12280 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12281 PyObject *resultobj;
12282 wxDC *arg1 = (wxDC *) 0 ;
12283 PyObject * obj0 = 0 ;
12284 char *kwnames[] = {
12285 (char *) "self", NULL
12286 };
12287
12288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12290 if (SWIG_arg_fail(1)) SWIG_fail;
12291 {
12292 PyThreadState* __tstate = wxPyBeginAllowThreads();
12293 (arg1)->EndDrawing();
12294
12295 wxPyEndAllowThreads(__tstate);
12296 if (PyErr_Occurred()) SWIG_fail;
12297 }
12298 Py_INCREF(Py_None); resultobj = Py_None;
12299 return resultobj;
12300 fail:
12301 return NULL;
12302 }
12303
12304
12305 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12306 PyObject *resultobj;
12307 wxDC *arg1 = (wxDC *) 0 ;
12308 int arg2 ;
12309 int arg3 ;
12310 wxColour *arg4 = 0 ;
12311 int arg5 = (int) wxFLOOD_SURFACE ;
12312 bool result;
12313 wxColour temp4 ;
12314 PyObject * obj0 = 0 ;
12315 PyObject * obj1 = 0 ;
12316 PyObject * obj2 = 0 ;
12317 PyObject * obj3 = 0 ;
12318 PyObject * obj4 = 0 ;
12319 char *kwnames[] = {
12320 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12321 };
12322
12323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12325 if (SWIG_arg_fail(1)) SWIG_fail;
12326 {
12327 arg2 = (int)(SWIG_As_int(obj1));
12328 if (SWIG_arg_fail(2)) SWIG_fail;
12329 }
12330 {
12331 arg3 = (int)(SWIG_As_int(obj2));
12332 if (SWIG_arg_fail(3)) SWIG_fail;
12333 }
12334 {
12335 arg4 = &temp4;
12336 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12337 }
12338 if (obj4) {
12339 {
12340 arg5 = (int)(SWIG_As_int(obj4));
12341 if (SWIG_arg_fail(5)) SWIG_fail;
12342 }
12343 }
12344 {
12345 PyThreadState* __tstate = wxPyBeginAllowThreads();
12346 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
12347
12348 wxPyEndAllowThreads(__tstate);
12349 if (PyErr_Occurred()) SWIG_fail;
12350 }
12351 {
12352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12353 }
12354 return resultobj;
12355 fail:
12356 return NULL;
12357 }
12358
12359
12360 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12361 PyObject *resultobj;
12362 wxDC *arg1 = (wxDC *) 0 ;
12363 wxPoint *arg2 = 0 ;
12364 wxColour *arg3 = 0 ;
12365 int arg4 = (int) wxFLOOD_SURFACE ;
12366 bool result;
12367 wxPoint temp2 ;
12368 wxColour temp3 ;
12369 PyObject * obj0 = 0 ;
12370 PyObject * obj1 = 0 ;
12371 PyObject * obj2 = 0 ;
12372 PyObject * obj3 = 0 ;
12373 char *kwnames[] = {
12374 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
12375 };
12376
12377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12379 if (SWIG_arg_fail(1)) SWIG_fail;
12380 {
12381 arg2 = &temp2;
12382 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12383 }
12384 {
12385 arg3 = &temp3;
12386 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
12387 }
12388 if (obj3) {
12389 {
12390 arg4 = (int)(SWIG_As_int(obj3));
12391 if (SWIG_arg_fail(4)) SWIG_fail;
12392 }
12393 }
12394 {
12395 PyThreadState* __tstate = wxPyBeginAllowThreads();
12396 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
12397
12398 wxPyEndAllowThreads(__tstate);
12399 if (PyErr_Occurred()) SWIG_fail;
12400 }
12401 {
12402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12403 }
12404 return resultobj;
12405 fail:
12406 return NULL;
12407 }
12408
12409
12410 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
12411 PyObject *resultobj;
12412 wxDC *arg1 = (wxDC *) 0 ;
12413 int arg2 ;
12414 int arg3 ;
12415 wxColour result;
12416 PyObject * obj0 = 0 ;
12417 PyObject * obj1 = 0 ;
12418 PyObject * obj2 = 0 ;
12419 char *kwnames[] = {
12420 (char *) "self",(char *) "x",(char *) "y", NULL
12421 };
12422
12423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
12424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12425 if (SWIG_arg_fail(1)) SWIG_fail;
12426 {
12427 arg2 = (int)(SWIG_As_int(obj1));
12428 if (SWIG_arg_fail(2)) SWIG_fail;
12429 }
12430 {
12431 arg3 = (int)(SWIG_As_int(obj2));
12432 if (SWIG_arg_fail(3)) SWIG_fail;
12433 }
12434 {
12435 PyThreadState* __tstate = wxPyBeginAllowThreads();
12436 result = wxDC_GetPixel(arg1,arg2,arg3);
12437
12438 wxPyEndAllowThreads(__tstate);
12439 if (PyErr_Occurred()) SWIG_fail;
12440 }
12441 {
12442 wxColour * resultptr;
12443 resultptr = new wxColour((wxColour &)(result));
12444 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12445 }
12446 return resultobj;
12447 fail:
12448 return NULL;
12449 }
12450
12451
12452 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12453 PyObject *resultobj;
12454 wxDC *arg1 = (wxDC *) 0 ;
12455 wxPoint *arg2 = 0 ;
12456 wxColour result;
12457 wxPoint temp2 ;
12458 PyObject * obj0 = 0 ;
12459 PyObject * obj1 = 0 ;
12460 char *kwnames[] = {
12461 (char *) "self",(char *) "pt", NULL
12462 };
12463
12464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
12465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12466 if (SWIG_arg_fail(1)) SWIG_fail;
12467 {
12468 arg2 = &temp2;
12469 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12470 }
12471 {
12472 PyThreadState* __tstate = wxPyBeginAllowThreads();
12473 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
12474
12475 wxPyEndAllowThreads(__tstate);
12476 if (PyErr_Occurred()) SWIG_fail;
12477 }
12478 {
12479 wxColour * resultptr;
12480 resultptr = new wxColour((wxColour &)(result));
12481 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12482 }
12483 return resultobj;
12484 fail:
12485 return NULL;
12486 }
12487
12488
12489 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
12490 PyObject *resultobj;
12491 wxDC *arg1 = (wxDC *) 0 ;
12492 int arg2 ;
12493 int arg3 ;
12494 int arg4 ;
12495 int arg5 ;
12496 PyObject * obj0 = 0 ;
12497 PyObject * obj1 = 0 ;
12498 PyObject * obj2 = 0 ;
12499 PyObject * obj3 = 0 ;
12500 PyObject * obj4 = 0 ;
12501 char *kwnames[] = {
12502 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
12503 };
12504
12505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12507 if (SWIG_arg_fail(1)) SWIG_fail;
12508 {
12509 arg2 = (int)(SWIG_As_int(obj1));
12510 if (SWIG_arg_fail(2)) SWIG_fail;
12511 }
12512 {
12513 arg3 = (int)(SWIG_As_int(obj2));
12514 if (SWIG_arg_fail(3)) SWIG_fail;
12515 }
12516 {
12517 arg4 = (int)(SWIG_As_int(obj3));
12518 if (SWIG_arg_fail(4)) SWIG_fail;
12519 }
12520 {
12521 arg5 = (int)(SWIG_As_int(obj4));
12522 if (SWIG_arg_fail(5)) SWIG_fail;
12523 }
12524 {
12525 PyThreadState* __tstate = wxPyBeginAllowThreads();
12526 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
12527
12528 wxPyEndAllowThreads(__tstate);
12529 if (PyErr_Occurred()) SWIG_fail;
12530 }
12531 Py_INCREF(Py_None); resultobj = Py_None;
12532 return resultobj;
12533 fail:
12534 return NULL;
12535 }
12536
12537
12538 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
12539 PyObject *resultobj;
12540 wxDC *arg1 = (wxDC *) 0 ;
12541 wxPoint *arg2 = 0 ;
12542 wxPoint *arg3 = 0 ;
12543 wxPoint temp2 ;
12544 wxPoint temp3 ;
12545 PyObject * obj0 = 0 ;
12546 PyObject * obj1 = 0 ;
12547 PyObject * obj2 = 0 ;
12548 char *kwnames[] = {
12549 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
12550 };
12551
12552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12554 if (SWIG_arg_fail(1)) SWIG_fail;
12555 {
12556 arg2 = &temp2;
12557 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12558 }
12559 {
12560 arg3 = &temp3;
12561 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12562 }
12563 {
12564 PyThreadState* __tstate = wxPyBeginAllowThreads();
12565 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
12566
12567 wxPyEndAllowThreads(__tstate);
12568 if (PyErr_Occurred()) SWIG_fail;
12569 }
12570 Py_INCREF(Py_None); resultobj = Py_None;
12571 return resultobj;
12572 fail:
12573 return NULL;
12574 }
12575
12576
12577 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
12578 PyObject *resultobj;
12579 wxDC *arg1 = (wxDC *) 0 ;
12580 int arg2 ;
12581 int arg3 ;
12582 PyObject * obj0 = 0 ;
12583 PyObject * obj1 = 0 ;
12584 PyObject * obj2 = 0 ;
12585 char *kwnames[] = {
12586 (char *) "self",(char *) "x",(char *) "y", NULL
12587 };
12588
12589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
12590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12591 if (SWIG_arg_fail(1)) SWIG_fail;
12592 {
12593 arg2 = (int)(SWIG_As_int(obj1));
12594 if (SWIG_arg_fail(2)) SWIG_fail;
12595 }
12596 {
12597 arg3 = (int)(SWIG_As_int(obj2));
12598 if (SWIG_arg_fail(3)) SWIG_fail;
12599 }
12600 {
12601 PyThreadState* __tstate = wxPyBeginAllowThreads();
12602 (arg1)->CrossHair(arg2,arg3);
12603
12604 wxPyEndAllowThreads(__tstate);
12605 if (PyErr_Occurred()) SWIG_fail;
12606 }
12607 Py_INCREF(Py_None); resultobj = Py_None;
12608 return resultobj;
12609 fail:
12610 return NULL;
12611 }
12612
12613
12614 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12615 PyObject *resultobj;
12616 wxDC *arg1 = (wxDC *) 0 ;
12617 wxPoint *arg2 = 0 ;
12618 wxPoint temp2 ;
12619 PyObject * obj0 = 0 ;
12620 PyObject * obj1 = 0 ;
12621 char *kwnames[] = {
12622 (char *) "self",(char *) "pt", NULL
12623 };
12624
12625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
12626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12627 if (SWIG_arg_fail(1)) SWIG_fail;
12628 {
12629 arg2 = &temp2;
12630 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12631 }
12632 {
12633 PyThreadState* __tstate = wxPyBeginAllowThreads();
12634 (arg1)->CrossHair((wxPoint const &)*arg2);
12635
12636 wxPyEndAllowThreads(__tstate);
12637 if (PyErr_Occurred()) SWIG_fail;
12638 }
12639 Py_INCREF(Py_None); resultobj = Py_None;
12640 return resultobj;
12641 fail:
12642 return NULL;
12643 }
12644
12645
12646 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
12647 PyObject *resultobj;
12648 wxDC *arg1 = (wxDC *) 0 ;
12649 int arg2 ;
12650 int arg3 ;
12651 int arg4 ;
12652 int arg5 ;
12653 int arg6 ;
12654 int arg7 ;
12655 PyObject * obj0 = 0 ;
12656 PyObject * obj1 = 0 ;
12657 PyObject * obj2 = 0 ;
12658 PyObject * obj3 = 0 ;
12659 PyObject * obj4 = 0 ;
12660 PyObject * obj5 = 0 ;
12661 PyObject * obj6 = 0 ;
12662 char *kwnames[] = {
12663 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
12664 };
12665
12666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12668 if (SWIG_arg_fail(1)) SWIG_fail;
12669 {
12670 arg2 = (int)(SWIG_As_int(obj1));
12671 if (SWIG_arg_fail(2)) SWIG_fail;
12672 }
12673 {
12674 arg3 = (int)(SWIG_As_int(obj2));
12675 if (SWIG_arg_fail(3)) SWIG_fail;
12676 }
12677 {
12678 arg4 = (int)(SWIG_As_int(obj3));
12679 if (SWIG_arg_fail(4)) SWIG_fail;
12680 }
12681 {
12682 arg5 = (int)(SWIG_As_int(obj4));
12683 if (SWIG_arg_fail(5)) SWIG_fail;
12684 }
12685 {
12686 arg6 = (int)(SWIG_As_int(obj5));
12687 if (SWIG_arg_fail(6)) SWIG_fail;
12688 }
12689 {
12690 arg7 = (int)(SWIG_As_int(obj6));
12691 if (SWIG_arg_fail(7)) SWIG_fail;
12692 }
12693 {
12694 PyThreadState* __tstate = wxPyBeginAllowThreads();
12695 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
12696
12697 wxPyEndAllowThreads(__tstate);
12698 if (PyErr_Occurred()) SWIG_fail;
12699 }
12700 Py_INCREF(Py_None); resultobj = Py_None;
12701 return resultobj;
12702 fail:
12703 return NULL;
12704 }
12705
12706
12707 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12708 PyObject *resultobj;
12709 wxDC *arg1 = (wxDC *) 0 ;
12710 wxPoint *arg2 = 0 ;
12711 wxPoint *arg3 = 0 ;
12712 wxPoint *arg4 = 0 ;
12713 wxPoint temp2 ;
12714 wxPoint temp3 ;
12715 wxPoint temp4 ;
12716 PyObject * obj0 = 0 ;
12717 PyObject * obj1 = 0 ;
12718 PyObject * obj2 = 0 ;
12719 PyObject * obj3 = 0 ;
12720 char *kwnames[] = {
12721 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
12722 };
12723
12724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12726 if (SWIG_arg_fail(1)) SWIG_fail;
12727 {
12728 arg2 = &temp2;
12729 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12730 }
12731 {
12732 arg3 = &temp3;
12733 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12734 }
12735 {
12736 arg4 = &temp4;
12737 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12738 }
12739 {
12740 PyThreadState* __tstate = wxPyBeginAllowThreads();
12741 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
12742
12743 wxPyEndAllowThreads(__tstate);
12744 if (PyErr_Occurred()) SWIG_fail;
12745 }
12746 Py_INCREF(Py_None); resultobj = Py_None;
12747 return resultobj;
12748 fail:
12749 return NULL;
12750 }
12751
12752
12753 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
12754 PyObject *resultobj;
12755 wxDC *arg1 = (wxDC *) 0 ;
12756 int arg2 ;
12757 int arg3 ;
12758 int arg4 ;
12759 int arg5 ;
12760 PyObject * obj0 = 0 ;
12761 PyObject * obj1 = 0 ;
12762 PyObject * obj2 = 0 ;
12763 PyObject * obj3 = 0 ;
12764 PyObject * obj4 = 0 ;
12765 char *kwnames[] = {
12766 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
12767 };
12768
12769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12771 if (SWIG_arg_fail(1)) SWIG_fail;
12772 {
12773 arg2 = (int)(SWIG_As_int(obj1));
12774 if (SWIG_arg_fail(2)) SWIG_fail;
12775 }
12776 {
12777 arg3 = (int)(SWIG_As_int(obj2));
12778 if (SWIG_arg_fail(3)) SWIG_fail;
12779 }
12780 {
12781 arg4 = (int)(SWIG_As_int(obj3));
12782 if (SWIG_arg_fail(4)) SWIG_fail;
12783 }
12784 {
12785 arg5 = (int)(SWIG_As_int(obj4));
12786 if (SWIG_arg_fail(5)) SWIG_fail;
12787 }
12788 {
12789 PyThreadState* __tstate = wxPyBeginAllowThreads();
12790 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
12791
12792 wxPyEndAllowThreads(__tstate);
12793 if (PyErr_Occurred()) SWIG_fail;
12794 }
12795 Py_INCREF(Py_None); resultobj = Py_None;
12796 return resultobj;
12797 fail:
12798 return NULL;
12799 }
12800
12801
12802 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
12803 PyObject *resultobj;
12804 wxDC *arg1 = (wxDC *) 0 ;
12805 wxRect *arg2 = 0 ;
12806 wxRect temp2 ;
12807 PyObject * obj0 = 0 ;
12808 PyObject * obj1 = 0 ;
12809 char *kwnames[] = {
12810 (char *) "self",(char *) "rect", NULL
12811 };
12812
12813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
12814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12815 if (SWIG_arg_fail(1)) SWIG_fail;
12816 {
12817 arg2 = &temp2;
12818 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12819 }
12820 {
12821 PyThreadState* __tstate = wxPyBeginAllowThreads();
12822 (arg1)->DrawCheckMark((wxRect const &)*arg2);
12823
12824 wxPyEndAllowThreads(__tstate);
12825 if (PyErr_Occurred()) SWIG_fail;
12826 }
12827 Py_INCREF(Py_None); resultobj = Py_None;
12828 return resultobj;
12829 fail:
12830 return NULL;
12831 }
12832
12833
12834 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
12835 PyObject *resultobj;
12836 wxDC *arg1 = (wxDC *) 0 ;
12837 int arg2 ;
12838 int arg3 ;
12839 int arg4 ;
12840 int arg5 ;
12841 double arg6 ;
12842 double arg7 ;
12843 PyObject * obj0 = 0 ;
12844 PyObject * obj1 = 0 ;
12845 PyObject * obj2 = 0 ;
12846 PyObject * obj3 = 0 ;
12847 PyObject * obj4 = 0 ;
12848 PyObject * obj5 = 0 ;
12849 PyObject * obj6 = 0 ;
12850 char *kwnames[] = {
12851 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
12852 };
12853
12854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12856 if (SWIG_arg_fail(1)) SWIG_fail;
12857 {
12858 arg2 = (int)(SWIG_As_int(obj1));
12859 if (SWIG_arg_fail(2)) SWIG_fail;
12860 }
12861 {
12862 arg3 = (int)(SWIG_As_int(obj2));
12863 if (SWIG_arg_fail(3)) SWIG_fail;
12864 }
12865 {
12866 arg4 = (int)(SWIG_As_int(obj3));
12867 if (SWIG_arg_fail(4)) SWIG_fail;
12868 }
12869 {
12870 arg5 = (int)(SWIG_As_int(obj4));
12871 if (SWIG_arg_fail(5)) SWIG_fail;
12872 }
12873 {
12874 arg6 = (double)(SWIG_As_double(obj5));
12875 if (SWIG_arg_fail(6)) SWIG_fail;
12876 }
12877 {
12878 arg7 = (double)(SWIG_As_double(obj6));
12879 if (SWIG_arg_fail(7)) SWIG_fail;
12880 }
12881 {
12882 PyThreadState* __tstate = wxPyBeginAllowThreads();
12883 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
12884
12885 wxPyEndAllowThreads(__tstate);
12886 if (PyErr_Occurred()) SWIG_fail;
12887 }
12888 Py_INCREF(Py_None); resultobj = Py_None;
12889 return resultobj;
12890 fail:
12891 return NULL;
12892 }
12893
12894
12895 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
12896 PyObject *resultobj;
12897 wxDC *arg1 = (wxDC *) 0 ;
12898 wxPoint *arg2 = 0 ;
12899 wxSize *arg3 = 0 ;
12900 double arg4 ;
12901 double arg5 ;
12902 wxPoint temp2 ;
12903 wxSize temp3 ;
12904 PyObject * obj0 = 0 ;
12905 PyObject * obj1 = 0 ;
12906 PyObject * obj2 = 0 ;
12907 PyObject * obj3 = 0 ;
12908 PyObject * obj4 = 0 ;
12909 char *kwnames[] = {
12910 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
12911 };
12912
12913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12915 if (SWIG_arg_fail(1)) SWIG_fail;
12916 {
12917 arg2 = &temp2;
12918 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12919 }
12920 {
12921 arg3 = &temp3;
12922 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
12923 }
12924 {
12925 arg4 = (double)(SWIG_As_double(obj3));
12926 if (SWIG_arg_fail(4)) SWIG_fail;
12927 }
12928 {
12929 arg5 = (double)(SWIG_As_double(obj4));
12930 if (SWIG_arg_fail(5)) SWIG_fail;
12931 }
12932 {
12933 PyThreadState* __tstate = wxPyBeginAllowThreads();
12934 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
12935
12936 wxPyEndAllowThreads(__tstate);
12937 if (PyErr_Occurred()) SWIG_fail;
12938 }
12939 Py_INCREF(Py_None); resultobj = Py_None;
12940 return resultobj;
12941 fail:
12942 return NULL;
12943 }
12944
12945
12946 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12947 PyObject *resultobj;
12948 wxDC *arg1 = (wxDC *) 0 ;
12949 int arg2 ;
12950 int arg3 ;
12951 PyObject * obj0 = 0 ;
12952 PyObject * obj1 = 0 ;
12953 PyObject * obj2 = 0 ;
12954 char *kwnames[] = {
12955 (char *) "self",(char *) "x",(char *) "y", NULL
12956 };
12957
12958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12960 if (SWIG_arg_fail(1)) SWIG_fail;
12961 {
12962 arg2 = (int)(SWIG_As_int(obj1));
12963 if (SWIG_arg_fail(2)) SWIG_fail;
12964 }
12965 {
12966 arg3 = (int)(SWIG_As_int(obj2));
12967 if (SWIG_arg_fail(3)) SWIG_fail;
12968 }
12969 {
12970 PyThreadState* __tstate = wxPyBeginAllowThreads();
12971 (arg1)->DrawPoint(arg2,arg3);
12972
12973 wxPyEndAllowThreads(__tstate);
12974 if (PyErr_Occurred()) SWIG_fail;
12975 }
12976 Py_INCREF(Py_None); resultobj = Py_None;
12977 return resultobj;
12978 fail:
12979 return NULL;
12980 }
12981
12982
12983 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12984 PyObject *resultobj;
12985 wxDC *arg1 = (wxDC *) 0 ;
12986 wxPoint *arg2 = 0 ;
12987 wxPoint temp2 ;
12988 PyObject * obj0 = 0 ;
12989 PyObject * obj1 = 0 ;
12990 char *kwnames[] = {
12991 (char *) "self",(char *) "pt", NULL
12992 };
12993
12994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
12995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12996 if (SWIG_arg_fail(1)) SWIG_fail;
12997 {
12998 arg2 = &temp2;
12999 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13000 }
13001 {
13002 PyThreadState* __tstate = wxPyBeginAllowThreads();
13003 (arg1)->DrawPoint((wxPoint const &)*arg2);
13004
13005 wxPyEndAllowThreads(__tstate);
13006 if (PyErr_Occurred()) SWIG_fail;
13007 }
13008 Py_INCREF(Py_None); resultobj = Py_None;
13009 return resultobj;
13010 fail:
13011 return NULL;
13012 }
13013
13014
13015 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13016 PyObject *resultobj;
13017 wxDC *arg1 = (wxDC *) 0 ;
13018 int arg2 ;
13019 int arg3 ;
13020 int arg4 ;
13021 int arg5 ;
13022 PyObject * obj0 = 0 ;
13023 PyObject * obj1 = 0 ;
13024 PyObject * obj2 = 0 ;
13025 PyObject * obj3 = 0 ;
13026 PyObject * obj4 = 0 ;
13027 char *kwnames[] = {
13028 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13029 };
13030
13031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13033 if (SWIG_arg_fail(1)) SWIG_fail;
13034 {
13035 arg2 = (int)(SWIG_As_int(obj1));
13036 if (SWIG_arg_fail(2)) SWIG_fail;
13037 }
13038 {
13039 arg3 = (int)(SWIG_As_int(obj2));
13040 if (SWIG_arg_fail(3)) SWIG_fail;
13041 }
13042 {
13043 arg4 = (int)(SWIG_As_int(obj3));
13044 if (SWIG_arg_fail(4)) SWIG_fail;
13045 }
13046 {
13047 arg5 = (int)(SWIG_As_int(obj4));
13048 if (SWIG_arg_fail(5)) SWIG_fail;
13049 }
13050 {
13051 PyThreadState* __tstate = wxPyBeginAllowThreads();
13052 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13053
13054 wxPyEndAllowThreads(__tstate);
13055 if (PyErr_Occurred()) SWIG_fail;
13056 }
13057 Py_INCREF(Py_None); resultobj = Py_None;
13058 return resultobj;
13059 fail:
13060 return NULL;
13061 }
13062
13063
13064 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13065 PyObject *resultobj;
13066 wxDC *arg1 = (wxDC *) 0 ;
13067 wxRect *arg2 = 0 ;
13068 wxRect temp2 ;
13069 PyObject * obj0 = 0 ;
13070 PyObject * obj1 = 0 ;
13071 char *kwnames[] = {
13072 (char *) "self",(char *) "rect", NULL
13073 };
13074
13075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13077 if (SWIG_arg_fail(1)) SWIG_fail;
13078 {
13079 arg2 = &temp2;
13080 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13081 }
13082 {
13083 PyThreadState* __tstate = wxPyBeginAllowThreads();
13084 (arg1)->DrawRectangle((wxRect const &)*arg2);
13085
13086 wxPyEndAllowThreads(__tstate);
13087 if (PyErr_Occurred()) SWIG_fail;
13088 }
13089 Py_INCREF(Py_None); resultobj = Py_None;
13090 return resultobj;
13091 fail:
13092 return NULL;
13093 }
13094
13095
13096 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13097 PyObject *resultobj;
13098 wxDC *arg1 = (wxDC *) 0 ;
13099 wxPoint *arg2 = 0 ;
13100 wxSize *arg3 = 0 ;
13101 wxPoint temp2 ;
13102 wxSize temp3 ;
13103 PyObject * obj0 = 0 ;
13104 PyObject * obj1 = 0 ;
13105 PyObject * obj2 = 0 ;
13106 char *kwnames[] = {
13107 (char *) "self",(char *) "pt",(char *) "sz", NULL
13108 };
13109
13110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13112 if (SWIG_arg_fail(1)) SWIG_fail;
13113 {
13114 arg2 = &temp2;
13115 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13116 }
13117 {
13118 arg3 = &temp3;
13119 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13120 }
13121 {
13122 PyThreadState* __tstate = wxPyBeginAllowThreads();
13123 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13124
13125 wxPyEndAllowThreads(__tstate);
13126 if (PyErr_Occurred()) SWIG_fail;
13127 }
13128 Py_INCREF(Py_None); resultobj = Py_None;
13129 return resultobj;
13130 fail:
13131 return NULL;
13132 }
13133
13134
13135 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13136 PyObject *resultobj;
13137 wxDC *arg1 = (wxDC *) 0 ;
13138 int arg2 ;
13139 int arg3 ;
13140 int arg4 ;
13141 int arg5 ;
13142 double arg6 ;
13143 PyObject * obj0 = 0 ;
13144 PyObject * obj1 = 0 ;
13145 PyObject * obj2 = 0 ;
13146 PyObject * obj3 = 0 ;
13147 PyObject * obj4 = 0 ;
13148 PyObject * obj5 = 0 ;
13149 char *kwnames[] = {
13150 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13151 };
13152
13153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13155 if (SWIG_arg_fail(1)) SWIG_fail;
13156 {
13157 arg2 = (int)(SWIG_As_int(obj1));
13158 if (SWIG_arg_fail(2)) SWIG_fail;
13159 }
13160 {
13161 arg3 = (int)(SWIG_As_int(obj2));
13162 if (SWIG_arg_fail(3)) SWIG_fail;
13163 }
13164 {
13165 arg4 = (int)(SWIG_As_int(obj3));
13166 if (SWIG_arg_fail(4)) SWIG_fail;
13167 }
13168 {
13169 arg5 = (int)(SWIG_As_int(obj4));
13170 if (SWIG_arg_fail(5)) SWIG_fail;
13171 }
13172 {
13173 arg6 = (double)(SWIG_As_double(obj5));
13174 if (SWIG_arg_fail(6)) SWIG_fail;
13175 }
13176 {
13177 PyThreadState* __tstate = wxPyBeginAllowThreads();
13178 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13179
13180 wxPyEndAllowThreads(__tstate);
13181 if (PyErr_Occurred()) SWIG_fail;
13182 }
13183 Py_INCREF(Py_None); resultobj = Py_None;
13184 return resultobj;
13185 fail:
13186 return NULL;
13187 }
13188
13189
13190 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13191 PyObject *resultobj;
13192 wxDC *arg1 = (wxDC *) 0 ;
13193 wxRect *arg2 = 0 ;
13194 double arg3 ;
13195 wxRect temp2 ;
13196 PyObject * obj0 = 0 ;
13197 PyObject * obj1 = 0 ;
13198 PyObject * obj2 = 0 ;
13199 char *kwnames[] = {
13200 (char *) "self",(char *) "r",(char *) "radius", NULL
13201 };
13202
13203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13205 if (SWIG_arg_fail(1)) SWIG_fail;
13206 {
13207 arg2 = &temp2;
13208 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13209 }
13210 {
13211 arg3 = (double)(SWIG_As_double(obj2));
13212 if (SWIG_arg_fail(3)) SWIG_fail;
13213 }
13214 {
13215 PyThreadState* __tstate = wxPyBeginAllowThreads();
13216 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13217
13218 wxPyEndAllowThreads(__tstate);
13219 if (PyErr_Occurred()) SWIG_fail;
13220 }
13221 Py_INCREF(Py_None); resultobj = Py_None;
13222 return resultobj;
13223 fail:
13224 return NULL;
13225 }
13226
13227
13228 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13229 PyObject *resultobj;
13230 wxDC *arg1 = (wxDC *) 0 ;
13231 wxPoint *arg2 = 0 ;
13232 wxSize *arg3 = 0 ;
13233 double arg4 ;
13234 wxPoint temp2 ;
13235 wxSize temp3 ;
13236 PyObject * obj0 = 0 ;
13237 PyObject * obj1 = 0 ;
13238 PyObject * obj2 = 0 ;
13239 PyObject * obj3 = 0 ;
13240 char *kwnames[] = {
13241 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13242 };
13243
13244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg3 = &temp3;
13253 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13254 }
13255 {
13256 arg4 = (double)(SWIG_As_double(obj3));
13257 if (SWIG_arg_fail(4)) SWIG_fail;
13258 }
13259 {
13260 PyThreadState* __tstate = wxPyBeginAllowThreads();
13261 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13262
13263 wxPyEndAllowThreads(__tstate);
13264 if (PyErr_Occurred()) SWIG_fail;
13265 }
13266 Py_INCREF(Py_None); resultobj = Py_None;
13267 return resultobj;
13268 fail:
13269 return NULL;
13270 }
13271
13272
13273 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13274 PyObject *resultobj;
13275 wxDC *arg1 = (wxDC *) 0 ;
13276 int arg2 ;
13277 int arg3 ;
13278 int arg4 ;
13279 PyObject * obj0 = 0 ;
13280 PyObject * obj1 = 0 ;
13281 PyObject * obj2 = 0 ;
13282 PyObject * obj3 = 0 ;
13283 char *kwnames[] = {
13284 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13285 };
13286
13287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13289 if (SWIG_arg_fail(1)) SWIG_fail;
13290 {
13291 arg2 = (int)(SWIG_As_int(obj1));
13292 if (SWIG_arg_fail(2)) SWIG_fail;
13293 }
13294 {
13295 arg3 = (int)(SWIG_As_int(obj2));
13296 if (SWIG_arg_fail(3)) SWIG_fail;
13297 }
13298 {
13299 arg4 = (int)(SWIG_As_int(obj3));
13300 if (SWIG_arg_fail(4)) SWIG_fail;
13301 }
13302 {
13303 PyThreadState* __tstate = wxPyBeginAllowThreads();
13304 (arg1)->DrawCircle(arg2,arg3,arg4);
13305
13306 wxPyEndAllowThreads(__tstate);
13307 if (PyErr_Occurred()) SWIG_fail;
13308 }
13309 Py_INCREF(Py_None); resultobj = Py_None;
13310 return resultobj;
13311 fail:
13312 return NULL;
13313 }
13314
13315
13316 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13317 PyObject *resultobj;
13318 wxDC *arg1 = (wxDC *) 0 ;
13319 wxPoint *arg2 = 0 ;
13320 int arg3 ;
13321 wxPoint temp2 ;
13322 PyObject * obj0 = 0 ;
13323 PyObject * obj1 = 0 ;
13324 PyObject * obj2 = 0 ;
13325 char *kwnames[] = {
13326 (char *) "self",(char *) "pt",(char *) "radius", NULL
13327 };
13328
13329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13331 if (SWIG_arg_fail(1)) SWIG_fail;
13332 {
13333 arg2 = &temp2;
13334 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13335 }
13336 {
13337 arg3 = (int)(SWIG_As_int(obj2));
13338 if (SWIG_arg_fail(3)) SWIG_fail;
13339 }
13340 {
13341 PyThreadState* __tstate = wxPyBeginAllowThreads();
13342 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13343
13344 wxPyEndAllowThreads(__tstate);
13345 if (PyErr_Occurred()) SWIG_fail;
13346 }
13347 Py_INCREF(Py_None); resultobj = Py_None;
13348 return resultobj;
13349 fail:
13350 return NULL;
13351 }
13352
13353
13354 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
13355 PyObject *resultobj;
13356 wxDC *arg1 = (wxDC *) 0 ;
13357 int arg2 ;
13358 int arg3 ;
13359 int arg4 ;
13360 int arg5 ;
13361 PyObject * obj0 = 0 ;
13362 PyObject * obj1 = 0 ;
13363 PyObject * obj2 = 0 ;
13364 PyObject * obj3 = 0 ;
13365 PyObject * obj4 = 0 ;
13366 char *kwnames[] = {
13367 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13368 };
13369
13370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13372 if (SWIG_arg_fail(1)) SWIG_fail;
13373 {
13374 arg2 = (int)(SWIG_As_int(obj1));
13375 if (SWIG_arg_fail(2)) SWIG_fail;
13376 }
13377 {
13378 arg3 = (int)(SWIG_As_int(obj2));
13379 if (SWIG_arg_fail(3)) SWIG_fail;
13380 }
13381 {
13382 arg4 = (int)(SWIG_As_int(obj3));
13383 if (SWIG_arg_fail(4)) SWIG_fail;
13384 }
13385 {
13386 arg5 = (int)(SWIG_As_int(obj4));
13387 if (SWIG_arg_fail(5)) SWIG_fail;
13388 }
13389 {
13390 PyThreadState* __tstate = wxPyBeginAllowThreads();
13391 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
13392
13393 wxPyEndAllowThreads(__tstate);
13394 if (PyErr_Occurred()) SWIG_fail;
13395 }
13396 Py_INCREF(Py_None); resultobj = Py_None;
13397 return resultobj;
13398 fail:
13399 return NULL;
13400 }
13401
13402
13403 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
13404 PyObject *resultobj;
13405 wxDC *arg1 = (wxDC *) 0 ;
13406 wxRect *arg2 = 0 ;
13407 wxRect temp2 ;
13408 PyObject * obj0 = 0 ;
13409 PyObject * obj1 = 0 ;
13410 char *kwnames[] = {
13411 (char *) "self",(char *) "rect", NULL
13412 };
13413
13414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
13415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13416 if (SWIG_arg_fail(1)) SWIG_fail;
13417 {
13418 arg2 = &temp2;
13419 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13420 }
13421 {
13422 PyThreadState* __tstate = wxPyBeginAllowThreads();
13423 (arg1)->DrawEllipse((wxRect const &)*arg2);
13424
13425 wxPyEndAllowThreads(__tstate);
13426 if (PyErr_Occurred()) SWIG_fail;
13427 }
13428 Py_INCREF(Py_None); resultobj = Py_None;
13429 return resultobj;
13430 fail:
13431 return NULL;
13432 }
13433
13434
13435 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13436 PyObject *resultobj;
13437 wxDC *arg1 = (wxDC *) 0 ;
13438 wxPoint *arg2 = 0 ;
13439 wxSize *arg3 = 0 ;
13440 wxPoint temp2 ;
13441 wxSize temp3 ;
13442 PyObject * obj0 = 0 ;
13443 PyObject * obj1 = 0 ;
13444 PyObject * obj2 = 0 ;
13445 char *kwnames[] = {
13446 (char *) "self",(char *) "pt",(char *) "sz", NULL
13447 };
13448
13449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13451 if (SWIG_arg_fail(1)) SWIG_fail;
13452 {
13453 arg2 = &temp2;
13454 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13455 }
13456 {
13457 arg3 = &temp3;
13458 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13459 }
13460 {
13461 PyThreadState* __tstate = wxPyBeginAllowThreads();
13462 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
13463
13464 wxPyEndAllowThreads(__tstate);
13465 if (PyErr_Occurred()) SWIG_fail;
13466 }
13467 Py_INCREF(Py_None); resultobj = Py_None;
13468 return resultobj;
13469 fail:
13470 return NULL;
13471 }
13472
13473
13474 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13475 PyObject *resultobj;
13476 wxDC *arg1 = (wxDC *) 0 ;
13477 wxIcon *arg2 = 0 ;
13478 int arg3 ;
13479 int arg4 ;
13480 PyObject * obj0 = 0 ;
13481 PyObject * obj1 = 0 ;
13482 PyObject * obj2 = 0 ;
13483 PyObject * obj3 = 0 ;
13484 char *kwnames[] = {
13485 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
13486 };
13487
13488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13490 if (SWIG_arg_fail(1)) SWIG_fail;
13491 {
13492 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13493 if (SWIG_arg_fail(2)) SWIG_fail;
13494 if (arg2 == NULL) {
13495 SWIG_null_ref("wxIcon");
13496 }
13497 if (SWIG_arg_fail(2)) SWIG_fail;
13498 }
13499 {
13500 arg3 = (int)(SWIG_As_int(obj2));
13501 if (SWIG_arg_fail(3)) SWIG_fail;
13502 }
13503 {
13504 arg4 = (int)(SWIG_As_int(obj3));
13505 if (SWIG_arg_fail(4)) SWIG_fail;
13506 }
13507 {
13508 PyThreadState* __tstate = wxPyBeginAllowThreads();
13509 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
13510
13511 wxPyEndAllowThreads(__tstate);
13512 if (PyErr_Occurred()) SWIG_fail;
13513 }
13514 Py_INCREF(Py_None); resultobj = Py_None;
13515 return resultobj;
13516 fail:
13517 return NULL;
13518 }
13519
13520
13521 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13522 PyObject *resultobj;
13523 wxDC *arg1 = (wxDC *) 0 ;
13524 wxIcon *arg2 = 0 ;
13525 wxPoint *arg3 = 0 ;
13526 wxPoint temp3 ;
13527 PyObject * obj0 = 0 ;
13528 PyObject * obj1 = 0 ;
13529 PyObject * obj2 = 0 ;
13530 char *kwnames[] = {
13531 (char *) "self",(char *) "icon",(char *) "pt", NULL
13532 };
13533
13534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13536 if (SWIG_arg_fail(1)) SWIG_fail;
13537 {
13538 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13539 if (SWIG_arg_fail(2)) SWIG_fail;
13540 if (arg2 == NULL) {
13541 SWIG_null_ref("wxIcon");
13542 }
13543 if (SWIG_arg_fail(2)) SWIG_fail;
13544 }
13545 {
13546 arg3 = &temp3;
13547 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13548 }
13549 {
13550 PyThreadState* __tstate = wxPyBeginAllowThreads();
13551 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
13552
13553 wxPyEndAllowThreads(__tstate);
13554 if (PyErr_Occurred()) SWIG_fail;
13555 }
13556 Py_INCREF(Py_None); resultobj = Py_None;
13557 return resultobj;
13558 fail:
13559 return NULL;
13560 }
13561
13562
13563 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13564 PyObject *resultobj;
13565 wxDC *arg1 = (wxDC *) 0 ;
13566 wxBitmap *arg2 = 0 ;
13567 int arg3 ;
13568 int arg4 ;
13569 bool arg5 = (bool) false ;
13570 PyObject * obj0 = 0 ;
13571 PyObject * obj1 = 0 ;
13572 PyObject * obj2 = 0 ;
13573 PyObject * obj3 = 0 ;
13574 PyObject * obj4 = 0 ;
13575 char *kwnames[] = {
13576 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
13577 };
13578
13579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13581 if (SWIG_arg_fail(1)) SWIG_fail;
13582 {
13583 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13584 if (SWIG_arg_fail(2)) SWIG_fail;
13585 if (arg2 == NULL) {
13586 SWIG_null_ref("wxBitmap");
13587 }
13588 if (SWIG_arg_fail(2)) SWIG_fail;
13589 }
13590 {
13591 arg3 = (int)(SWIG_As_int(obj2));
13592 if (SWIG_arg_fail(3)) SWIG_fail;
13593 }
13594 {
13595 arg4 = (int)(SWIG_As_int(obj3));
13596 if (SWIG_arg_fail(4)) SWIG_fail;
13597 }
13598 if (obj4) {
13599 {
13600 arg5 = (bool)(SWIG_As_bool(obj4));
13601 if (SWIG_arg_fail(5)) SWIG_fail;
13602 }
13603 }
13604 {
13605 PyThreadState* __tstate = wxPyBeginAllowThreads();
13606 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
13607
13608 wxPyEndAllowThreads(__tstate);
13609 if (PyErr_Occurred()) SWIG_fail;
13610 }
13611 Py_INCREF(Py_None); resultobj = Py_None;
13612 return resultobj;
13613 fail:
13614 return NULL;
13615 }
13616
13617
13618 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13619 PyObject *resultobj;
13620 wxDC *arg1 = (wxDC *) 0 ;
13621 wxBitmap *arg2 = 0 ;
13622 wxPoint *arg3 = 0 ;
13623 bool arg4 = (bool) false ;
13624 wxPoint temp3 ;
13625 PyObject * obj0 = 0 ;
13626 PyObject * obj1 = 0 ;
13627 PyObject * obj2 = 0 ;
13628 PyObject * obj3 = 0 ;
13629 char *kwnames[] = {
13630 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
13631 };
13632
13633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13635 if (SWIG_arg_fail(1)) SWIG_fail;
13636 {
13637 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13638 if (SWIG_arg_fail(2)) SWIG_fail;
13639 if (arg2 == NULL) {
13640 SWIG_null_ref("wxBitmap");
13641 }
13642 if (SWIG_arg_fail(2)) SWIG_fail;
13643 }
13644 {
13645 arg3 = &temp3;
13646 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13647 }
13648 if (obj3) {
13649 {
13650 arg4 = (bool)(SWIG_As_bool(obj3));
13651 if (SWIG_arg_fail(4)) SWIG_fail;
13652 }
13653 }
13654 {
13655 PyThreadState* __tstate = wxPyBeginAllowThreads();
13656 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
13657
13658 wxPyEndAllowThreads(__tstate);
13659 if (PyErr_Occurred()) SWIG_fail;
13660 }
13661 Py_INCREF(Py_None); resultobj = Py_None;
13662 return resultobj;
13663 fail:
13664 return NULL;
13665 }
13666
13667
13668 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
13669 PyObject *resultobj;
13670 wxDC *arg1 = (wxDC *) 0 ;
13671 wxString *arg2 = 0 ;
13672 int arg3 ;
13673 int arg4 ;
13674 bool temp2 = false ;
13675 PyObject * obj0 = 0 ;
13676 PyObject * obj1 = 0 ;
13677 PyObject * obj2 = 0 ;
13678 PyObject * obj3 = 0 ;
13679 char *kwnames[] = {
13680 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
13681 };
13682
13683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13685 if (SWIG_arg_fail(1)) SWIG_fail;
13686 {
13687 arg2 = wxString_in_helper(obj1);
13688 if (arg2 == NULL) SWIG_fail;
13689 temp2 = true;
13690 }
13691 {
13692 arg3 = (int)(SWIG_As_int(obj2));
13693 if (SWIG_arg_fail(3)) SWIG_fail;
13694 }
13695 {
13696 arg4 = (int)(SWIG_As_int(obj3));
13697 if (SWIG_arg_fail(4)) SWIG_fail;
13698 }
13699 {
13700 PyThreadState* __tstate = wxPyBeginAllowThreads();
13701 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
13702
13703 wxPyEndAllowThreads(__tstate);
13704 if (PyErr_Occurred()) SWIG_fail;
13705 }
13706 Py_INCREF(Py_None); resultobj = Py_None;
13707 {
13708 if (temp2)
13709 delete arg2;
13710 }
13711 return resultobj;
13712 fail:
13713 {
13714 if (temp2)
13715 delete arg2;
13716 }
13717 return NULL;
13718 }
13719
13720
13721 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13722 PyObject *resultobj;
13723 wxDC *arg1 = (wxDC *) 0 ;
13724 wxString *arg2 = 0 ;
13725 wxPoint *arg3 = 0 ;
13726 bool temp2 = false ;
13727 wxPoint temp3 ;
13728 PyObject * obj0 = 0 ;
13729 PyObject * obj1 = 0 ;
13730 PyObject * obj2 = 0 ;
13731 char *kwnames[] = {
13732 (char *) "self",(char *) "text",(char *) "pt", NULL
13733 };
13734
13735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13737 if (SWIG_arg_fail(1)) SWIG_fail;
13738 {
13739 arg2 = wxString_in_helper(obj1);
13740 if (arg2 == NULL) SWIG_fail;
13741 temp2 = true;
13742 }
13743 {
13744 arg3 = &temp3;
13745 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13746 }
13747 {
13748 PyThreadState* __tstate = wxPyBeginAllowThreads();
13749 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
13750
13751 wxPyEndAllowThreads(__tstate);
13752 if (PyErr_Occurred()) SWIG_fail;
13753 }
13754 Py_INCREF(Py_None); resultobj = Py_None;
13755 {
13756 if (temp2)
13757 delete arg2;
13758 }
13759 return resultobj;
13760 fail:
13761 {
13762 if (temp2)
13763 delete arg2;
13764 }
13765 return NULL;
13766 }
13767
13768
13769 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
13770 PyObject *resultobj;
13771 wxDC *arg1 = (wxDC *) 0 ;
13772 wxString *arg2 = 0 ;
13773 int arg3 ;
13774 int arg4 ;
13775 double arg5 ;
13776 bool temp2 = false ;
13777 PyObject * obj0 = 0 ;
13778 PyObject * obj1 = 0 ;
13779 PyObject * obj2 = 0 ;
13780 PyObject * obj3 = 0 ;
13781 PyObject * obj4 = 0 ;
13782 char *kwnames[] = {
13783 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
13784 };
13785
13786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13788 if (SWIG_arg_fail(1)) SWIG_fail;
13789 {
13790 arg2 = wxString_in_helper(obj1);
13791 if (arg2 == NULL) SWIG_fail;
13792 temp2 = true;
13793 }
13794 {
13795 arg3 = (int)(SWIG_As_int(obj2));
13796 if (SWIG_arg_fail(3)) SWIG_fail;
13797 }
13798 {
13799 arg4 = (int)(SWIG_As_int(obj3));
13800 if (SWIG_arg_fail(4)) SWIG_fail;
13801 }
13802 {
13803 arg5 = (double)(SWIG_As_double(obj4));
13804 if (SWIG_arg_fail(5)) SWIG_fail;
13805 }
13806 {
13807 PyThreadState* __tstate = wxPyBeginAllowThreads();
13808 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
13809
13810 wxPyEndAllowThreads(__tstate);
13811 if (PyErr_Occurred()) SWIG_fail;
13812 }
13813 Py_INCREF(Py_None); resultobj = Py_None;
13814 {
13815 if (temp2)
13816 delete arg2;
13817 }
13818 return resultobj;
13819 fail:
13820 {
13821 if (temp2)
13822 delete arg2;
13823 }
13824 return NULL;
13825 }
13826
13827
13828 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13829 PyObject *resultobj;
13830 wxDC *arg1 = (wxDC *) 0 ;
13831 wxString *arg2 = 0 ;
13832 wxPoint *arg3 = 0 ;
13833 double arg4 ;
13834 bool temp2 = false ;
13835 wxPoint temp3 ;
13836 PyObject * obj0 = 0 ;
13837 PyObject * obj1 = 0 ;
13838 PyObject * obj2 = 0 ;
13839 PyObject * obj3 = 0 ;
13840 char *kwnames[] = {
13841 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
13842 };
13843
13844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13846 if (SWIG_arg_fail(1)) SWIG_fail;
13847 {
13848 arg2 = wxString_in_helper(obj1);
13849 if (arg2 == NULL) SWIG_fail;
13850 temp2 = true;
13851 }
13852 {
13853 arg3 = &temp3;
13854 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13855 }
13856 {
13857 arg4 = (double)(SWIG_As_double(obj3));
13858 if (SWIG_arg_fail(4)) SWIG_fail;
13859 }
13860 {
13861 PyThreadState* __tstate = wxPyBeginAllowThreads();
13862 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
13863
13864 wxPyEndAllowThreads(__tstate);
13865 if (PyErr_Occurred()) SWIG_fail;
13866 }
13867 Py_INCREF(Py_None); resultobj = Py_None;
13868 {
13869 if (temp2)
13870 delete arg2;
13871 }
13872 return resultobj;
13873 fail:
13874 {
13875 if (temp2)
13876 delete arg2;
13877 }
13878 return NULL;
13879 }
13880
13881
13882 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
13883 PyObject *resultobj;
13884 wxDC *arg1 = (wxDC *) 0 ;
13885 int arg2 ;
13886 int arg3 ;
13887 int arg4 ;
13888 int arg5 ;
13889 wxDC *arg6 = (wxDC *) 0 ;
13890 int arg7 ;
13891 int arg8 ;
13892 int arg9 = (int) wxCOPY ;
13893 bool arg10 = (bool) false ;
13894 int arg11 = (int) -1 ;
13895 int arg12 = (int) -1 ;
13896 bool result;
13897 PyObject * obj0 = 0 ;
13898 PyObject * obj1 = 0 ;
13899 PyObject * obj2 = 0 ;
13900 PyObject * obj3 = 0 ;
13901 PyObject * obj4 = 0 ;
13902 PyObject * obj5 = 0 ;
13903 PyObject * obj6 = 0 ;
13904 PyObject * obj7 = 0 ;
13905 PyObject * obj8 = 0 ;
13906 PyObject * obj9 = 0 ;
13907 PyObject * obj10 = 0 ;
13908 PyObject * obj11 = 0 ;
13909 char *kwnames[] = {
13910 (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
13911 };
13912
13913 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;
13914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13915 if (SWIG_arg_fail(1)) SWIG_fail;
13916 {
13917 arg2 = (int)(SWIG_As_int(obj1));
13918 if (SWIG_arg_fail(2)) SWIG_fail;
13919 }
13920 {
13921 arg3 = (int)(SWIG_As_int(obj2));
13922 if (SWIG_arg_fail(3)) SWIG_fail;
13923 }
13924 {
13925 arg4 = (int)(SWIG_As_int(obj3));
13926 if (SWIG_arg_fail(4)) SWIG_fail;
13927 }
13928 {
13929 arg5 = (int)(SWIG_As_int(obj4));
13930 if (SWIG_arg_fail(5)) SWIG_fail;
13931 }
13932 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13933 if (SWIG_arg_fail(6)) SWIG_fail;
13934 {
13935 arg7 = (int)(SWIG_As_int(obj6));
13936 if (SWIG_arg_fail(7)) SWIG_fail;
13937 }
13938 {
13939 arg8 = (int)(SWIG_As_int(obj7));
13940 if (SWIG_arg_fail(8)) SWIG_fail;
13941 }
13942 if (obj8) {
13943 {
13944 arg9 = (int)(SWIG_As_int(obj8));
13945 if (SWIG_arg_fail(9)) SWIG_fail;
13946 }
13947 }
13948 if (obj9) {
13949 {
13950 arg10 = (bool)(SWIG_As_bool(obj9));
13951 if (SWIG_arg_fail(10)) SWIG_fail;
13952 }
13953 }
13954 if (obj10) {
13955 {
13956 arg11 = (int)(SWIG_As_int(obj10));
13957 if (SWIG_arg_fail(11)) SWIG_fail;
13958 }
13959 }
13960 if (obj11) {
13961 {
13962 arg12 = (int)(SWIG_As_int(obj11));
13963 if (SWIG_arg_fail(12)) SWIG_fail;
13964 }
13965 }
13966 {
13967 PyThreadState* __tstate = wxPyBeginAllowThreads();
13968 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
13969
13970 wxPyEndAllowThreads(__tstate);
13971 if (PyErr_Occurred()) SWIG_fail;
13972 }
13973 {
13974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13975 }
13976 return resultobj;
13977 fail:
13978 return NULL;
13979 }
13980
13981
13982 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13983 PyObject *resultobj;
13984 wxDC *arg1 = (wxDC *) 0 ;
13985 wxPoint *arg2 = 0 ;
13986 wxSize *arg3 = 0 ;
13987 wxDC *arg4 = (wxDC *) 0 ;
13988 wxPoint *arg5 = 0 ;
13989 int arg6 = (int) wxCOPY ;
13990 bool arg7 = (bool) false ;
13991 wxPoint const &arg8_defvalue = wxDefaultPosition ;
13992 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
13993 bool result;
13994 wxPoint temp2 ;
13995 wxSize temp3 ;
13996 wxPoint temp5 ;
13997 wxPoint temp8 ;
13998 PyObject * obj0 = 0 ;
13999 PyObject * obj1 = 0 ;
14000 PyObject * obj2 = 0 ;
14001 PyObject * obj3 = 0 ;
14002 PyObject * obj4 = 0 ;
14003 PyObject * obj5 = 0 ;
14004 PyObject * obj6 = 0 ;
14005 PyObject * obj7 = 0 ;
14006 char *kwnames[] = {
14007 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
14008 };
14009
14010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
14011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14012 if (SWIG_arg_fail(1)) SWIG_fail;
14013 {
14014 arg2 = &temp2;
14015 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14016 }
14017 {
14018 arg3 = &temp3;
14019 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14020 }
14021 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14022 if (SWIG_arg_fail(4)) SWIG_fail;
14023 {
14024 arg5 = &temp5;
14025 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14026 }
14027 if (obj5) {
14028 {
14029 arg6 = (int)(SWIG_As_int(obj5));
14030 if (SWIG_arg_fail(6)) SWIG_fail;
14031 }
14032 }
14033 if (obj6) {
14034 {
14035 arg7 = (bool)(SWIG_As_bool(obj6));
14036 if (SWIG_arg_fail(7)) SWIG_fail;
14037 }
14038 }
14039 if (obj7) {
14040 {
14041 arg8 = &temp8;
14042 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14043 }
14044 }
14045 {
14046 PyThreadState* __tstate = wxPyBeginAllowThreads();
14047 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14048
14049 wxPyEndAllowThreads(__tstate);
14050 if (PyErr_Occurred()) SWIG_fail;
14051 }
14052 {
14053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14054 }
14055 return resultobj;
14056 fail:
14057 return NULL;
14058 }
14059
14060
14061 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14062 PyObject *resultobj;
14063 wxDC *arg1 = (wxDC *) 0 ;
14064 int arg2 ;
14065 int arg3 ;
14066 int arg4 ;
14067 int arg5 ;
14068 PyObject * obj0 = 0 ;
14069 PyObject * obj1 = 0 ;
14070 PyObject * obj2 = 0 ;
14071 PyObject * obj3 = 0 ;
14072 PyObject * obj4 = 0 ;
14073 char *kwnames[] = {
14074 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14075 };
14076
14077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14079 if (SWIG_arg_fail(1)) SWIG_fail;
14080 {
14081 arg2 = (int)(SWIG_As_int(obj1));
14082 if (SWIG_arg_fail(2)) SWIG_fail;
14083 }
14084 {
14085 arg3 = (int)(SWIG_As_int(obj2));
14086 if (SWIG_arg_fail(3)) SWIG_fail;
14087 }
14088 {
14089 arg4 = (int)(SWIG_As_int(obj3));
14090 if (SWIG_arg_fail(4)) SWIG_fail;
14091 }
14092 {
14093 arg5 = (int)(SWIG_As_int(obj4));
14094 if (SWIG_arg_fail(5)) SWIG_fail;
14095 }
14096 {
14097 PyThreadState* __tstate = wxPyBeginAllowThreads();
14098 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14099
14100 wxPyEndAllowThreads(__tstate);
14101 if (PyErr_Occurred()) SWIG_fail;
14102 }
14103 Py_INCREF(Py_None); resultobj = Py_None;
14104 return resultobj;
14105 fail:
14106 return NULL;
14107 }
14108
14109
14110 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14111 PyObject *resultobj;
14112 wxDC *arg1 = (wxDC *) 0 ;
14113 wxPoint *arg2 = 0 ;
14114 wxSize *arg3 = 0 ;
14115 wxPoint temp2 ;
14116 wxSize temp3 ;
14117 PyObject * obj0 = 0 ;
14118 PyObject * obj1 = 0 ;
14119 PyObject * obj2 = 0 ;
14120 char *kwnames[] = {
14121 (char *) "self",(char *) "pt",(char *) "sz", NULL
14122 };
14123
14124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14126 if (SWIG_arg_fail(1)) SWIG_fail;
14127 {
14128 arg2 = &temp2;
14129 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14130 }
14131 {
14132 arg3 = &temp3;
14133 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14134 }
14135 {
14136 PyThreadState* __tstate = wxPyBeginAllowThreads();
14137 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14138
14139 wxPyEndAllowThreads(__tstate);
14140 if (PyErr_Occurred()) SWIG_fail;
14141 }
14142 Py_INCREF(Py_None); resultobj = Py_None;
14143 return resultobj;
14144 fail:
14145 return NULL;
14146 }
14147
14148
14149 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14150 PyObject *resultobj;
14151 wxDC *arg1 = (wxDC *) 0 ;
14152 wxRegion *arg2 = 0 ;
14153 PyObject * obj0 = 0 ;
14154 PyObject * obj1 = 0 ;
14155 char *kwnames[] = {
14156 (char *) "self",(char *) "region", NULL
14157 };
14158
14159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14161 if (SWIG_arg_fail(1)) SWIG_fail;
14162 {
14163 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14164 if (SWIG_arg_fail(2)) SWIG_fail;
14165 if (arg2 == NULL) {
14166 SWIG_null_ref("wxRegion");
14167 }
14168 if (SWIG_arg_fail(2)) SWIG_fail;
14169 }
14170 {
14171 PyThreadState* __tstate = wxPyBeginAllowThreads();
14172 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14173
14174 wxPyEndAllowThreads(__tstate);
14175 if (PyErr_Occurred()) SWIG_fail;
14176 }
14177 Py_INCREF(Py_None); resultobj = Py_None;
14178 return resultobj;
14179 fail:
14180 return NULL;
14181 }
14182
14183
14184 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14185 PyObject *resultobj;
14186 wxDC *arg1 = (wxDC *) 0 ;
14187 wxRect *arg2 = 0 ;
14188 wxRect temp2 ;
14189 PyObject * obj0 = 0 ;
14190 PyObject * obj1 = 0 ;
14191 char *kwnames[] = {
14192 (char *) "self",(char *) "rect", NULL
14193 };
14194
14195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14197 if (SWIG_arg_fail(1)) SWIG_fail;
14198 {
14199 arg2 = &temp2;
14200 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14201 }
14202 {
14203 PyThreadState* __tstate = wxPyBeginAllowThreads();
14204 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14205
14206 wxPyEndAllowThreads(__tstate);
14207 if (PyErr_Occurred()) SWIG_fail;
14208 }
14209 Py_INCREF(Py_None); resultobj = Py_None;
14210 return resultobj;
14211 fail:
14212 return NULL;
14213 }
14214
14215
14216 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14217 PyObject *resultobj;
14218 wxDC *arg1 = (wxDC *) 0 ;
14219 int arg2 ;
14220 wxPoint *arg3 = (wxPoint *) 0 ;
14221 int arg4 = (int) 0 ;
14222 int arg5 = (int) 0 ;
14223 PyObject * obj0 = 0 ;
14224 PyObject * obj1 = 0 ;
14225 PyObject * obj2 = 0 ;
14226 PyObject * obj3 = 0 ;
14227 char *kwnames[] = {
14228 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14229 };
14230
14231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14233 if (SWIG_arg_fail(1)) SWIG_fail;
14234 {
14235 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14236 if (arg3 == NULL) SWIG_fail;
14237 }
14238 if (obj2) {
14239 {
14240 arg4 = (int)(SWIG_As_int(obj2));
14241 if (SWIG_arg_fail(4)) SWIG_fail;
14242 }
14243 }
14244 if (obj3) {
14245 {
14246 arg5 = (int)(SWIG_As_int(obj3));
14247 if (SWIG_arg_fail(5)) SWIG_fail;
14248 }
14249 }
14250 {
14251 PyThreadState* __tstate = wxPyBeginAllowThreads();
14252 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14253
14254 wxPyEndAllowThreads(__tstate);
14255 if (PyErr_Occurred()) SWIG_fail;
14256 }
14257 Py_INCREF(Py_None); resultobj = Py_None;
14258 {
14259 if (arg3) delete [] arg3;
14260 }
14261 return resultobj;
14262 fail:
14263 {
14264 if (arg3) delete [] arg3;
14265 }
14266 return NULL;
14267 }
14268
14269
14270 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14271 PyObject *resultobj;
14272 wxDC *arg1 = (wxDC *) 0 ;
14273 int arg2 ;
14274 wxPoint *arg3 = (wxPoint *) 0 ;
14275 int arg4 = (int) 0 ;
14276 int arg5 = (int) 0 ;
14277 int arg6 = (int) wxODDEVEN_RULE ;
14278 PyObject * obj0 = 0 ;
14279 PyObject * obj1 = 0 ;
14280 PyObject * obj2 = 0 ;
14281 PyObject * obj3 = 0 ;
14282 PyObject * obj4 = 0 ;
14283 char *kwnames[] = {
14284 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14285 };
14286
14287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14289 if (SWIG_arg_fail(1)) SWIG_fail;
14290 {
14291 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14292 if (arg3 == NULL) SWIG_fail;
14293 }
14294 if (obj2) {
14295 {
14296 arg4 = (int)(SWIG_As_int(obj2));
14297 if (SWIG_arg_fail(4)) SWIG_fail;
14298 }
14299 }
14300 if (obj3) {
14301 {
14302 arg5 = (int)(SWIG_As_int(obj3));
14303 if (SWIG_arg_fail(5)) SWIG_fail;
14304 }
14305 }
14306 if (obj4) {
14307 {
14308 arg6 = (int)(SWIG_As_int(obj4));
14309 if (SWIG_arg_fail(6)) SWIG_fail;
14310 }
14311 }
14312 {
14313 PyThreadState* __tstate = wxPyBeginAllowThreads();
14314 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14315
14316 wxPyEndAllowThreads(__tstate);
14317 if (PyErr_Occurred()) SWIG_fail;
14318 }
14319 Py_INCREF(Py_None); resultobj = Py_None;
14320 {
14321 if (arg3) delete [] arg3;
14322 }
14323 return resultobj;
14324 fail:
14325 {
14326 if (arg3) delete [] arg3;
14327 }
14328 return NULL;
14329 }
14330
14331
14332 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14333 PyObject *resultobj;
14334 wxDC *arg1 = (wxDC *) 0 ;
14335 wxString *arg2 = 0 ;
14336 wxRect *arg3 = 0 ;
14337 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14338 int arg5 = (int) -1 ;
14339 bool temp2 = false ;
14340 wxRect temp3 ;
14341 PyObject * obj0 = 0 ;
14342 PyObject * obj1 = 0 ;
14343 PyObject * obj2 = 0 ;
14344 PyObject * obj3 = 0 ;
14345 PyObject * obj4 = 0 ;
14346 char *kwnames[] = {
14347 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14348 };
14349
14350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14352 if (SWIG_arg_fail(1)) SWIG_fail;
14353 {
14354 arg2 = wxString_in_helper(obj1);
14355 if (arg2 == NULL) SWIG_fail;
14356 temp2 = true;
14357 }
14358 {
14359 arg3 = &temp3;
14360 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
14361 }
14362 if (obj3) {
14363 {
14364 arg4 = (int)(SWIG_As_int(obj3));
14365 if (SWIG_arg_fail(4)) SWIG_fail;
14366 }
14367 }
14368 if (obj4) {
14369 {
14370 arg5 = (int)(SWIG_As_int(obj4));
14371 if (SWIG_arg_fail(5)) SWIG_fail;
14372 }
14373 }
14374 {
14375 PyThreadState* __tstate = wxPyBeginAllowThreads();
14376 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
14377
14378 wxPyEndAllowThreads(__tstate);
14379 if (PyErr_Occurred()) SWIG_fail;
14380 }
14381 Py_INCREF(Py_None); resultobj = Py_None;
14382 {
14383 if (temp2)
14384 delete arg2;
14385 }
14386 return resultobj;
14387 fail:
14388 {
14389 if (temp2)
14390 delete arg2;
14391 }
14392 return NULL;
14393 }
14394
14395
14396 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14397 PyObject *resultobj;
14398 wxDC *arg1 = (wxDC *) 0 ;
14399 wxString *arg2 = 0 ;
14400 wxBitmap *arg3 = 0 ;
14401 wxRect *arg4 = 0 ;
14402 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14403 int arg6 = (int) -1 ;
14404 wxRect result;
14405 bool temp2 = false ;
14406 wxRect temp4 ;
14407 PyObject * obj0 = 0 ;
14408 PyObject * obj1 = 0 ;
14409 PyObject * obj2 = 0 ;
14410 PyObject * obj3 = 0 ;
14411 PyObject * obj4 = 0 ;
14412 PyObject * obj5 = 0 ;
14413 char *kwnames[] = {
14414 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14415 };
14416
14417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14419 if (SWIG_arg_fail(1)) SWIG_fail;
14420 {
14421 arg2 = wxString_in_helper(obj1);
14422 if (arg2 == NULL) SWIG_fail;
14423 temp2 = true;
14424 }
14425 {
14426 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14427 if (SWIG_arg_fail(3)) SWIG_fail;
14428 if (arg3 == NULL) {
14429 SWIG_null_ref("wxBitmap");
14430 }
14431 if (SWIG_arg_fail(3)) SWIG_fail;
14432 }
14433 {
14434 arg4 = &temp4;
14435 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
14436 }
14437 if (obj4) {
14438 {
14439 arg5 = (int)(SWIG_As_int(obj4));
14440 if (SWIG_arg_fail(5)) SWIG_fail;
14441 }
14442 }
14443 if (obj5) {
14444 {
14445 arg6 = (int)(SWIG_As_int(obj5));
14446 if (SWIG_arg_fail(6)) SWIG_fail;
14447 }
14448 }
14449 {
14450 PyThreadState* __tstate = wxPyBeginAllowThreads();
14451 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
14452
14453 wxPyEndAllowThreads(__tstate);
14454 if (PyErr_Occurred()) SWIG_fail;
14455 }
14456 {
14457 wxRect * resultptr;
14458 resultptr = new wxRect((wxRect &)(result));
14459 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14460 }
14461 {
14462 if (temp2)
14463 delete arg2;
14464 }
14465 return resultobj;
14466 fail:
14467 {
14468 if (temp2)
14469 delete arg2;
14470 }
14471 return NULL;
14472 }
14473
14474
14475 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
14476 PyObject *resultobj;
14477 wxDC *arg1 = (wxDC *) 0 ;
14478 int arg2 ;
14479 wxPoint *arg3 = (wxPoint *) 0 ;
14480 PyObject * obj0 = 0 ;
14481 PyObject * obj1 = 0 ;
14482 char *kwnames[] = {
14483 (char *) "self",(char *) "points", NULL
14484 };
14485
14486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
14487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14488 if (SWIG_arg_fail(1)) SWIG_fail;
14489 {
14490 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14491 if (arg3 == NULL) SWIG_fail;
14492 }
14493 {
14494 PyThreadState* __tstate = wxPyBeginAllowThreads();
14495 (arg1)->DrawSpline(arg2,arg3);
14496
14497 wxPyEndAllowThreads(__tstate);
14498 if (PyErr_Occurred()) SWIG_fail;
14499 }
14500 Py_INCREF(Py_None); resultobj = Py_None;
14501 {
14502 if (arg3) delete [] arg3;
14503 }
14504 return resultobj;
14505 fail:
14506 {
14507 if (arg3) delete [] arg3;
14508 }
14509 return NULL;
14510 }
14511
14512
14513 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
14514 PyObject *resultobj;
14515 wxDC *arg1 = (wxDC *) 0 ;
14516 PyObject * obj0 = 0 ;
14517 char *kwnames[] = {
14518 (char *) "self", NULL
14519 };
14520
14521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
14522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14523 if (SWIG_arg_fail(1)) SWIG_fail;
14524 {
14525 PyThreadState* __tstate = wxPyBeginAllowThreads();
14526 (arg1)->Clear();
14527
14528 wxPyEndAllowThreads(__tstate);
14529 if (PyErr_Occurred()) SWIG_fail;
14530 }
14531 Py_INCREF(Py_None); resultobj = Py_None;
14532 return resultobj;
14533 fail:
14534 return NULL;
14535 }
14536
14537
14538 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14539 PyObject *resultobj;
14540 wxDC *arg1 = (wxDC *) 0 ;
14541 wxString *arg2 = 0 ;
14542 bool result;
14543 bool temp2 = false ;
14544 PyObject * obj0 = 0 ;
14545 PyObject * obj1 = 0 ;
14546 char *kwnames[] = {
14547 (char *) "self",(char *) "message", NULL
14548 };
14549
14550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
14551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14552 if (SWIG_arg_fail(1)) SWIG_fail;
14553 {
14554 arg2 = wxString_in_helper(obj1);
14555 if (arg2 == NULL) SWIG_fail;
14556 temp2 = true;
14557 }
14558 {
14559 PyThreadState* __tstate = wxPyBeginAllowThreads();
14560 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
14561
14562 wxPyEndAllowThreads(__tstate);
14563 if (PyErr_Occurred()) SWIG_fail;
14564 }
14565 {
14566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14567 }
14568 {
14569 if (temp2)
14570 delete arg2;
14571 }
14572 return resultobj;
14573 fail:
14574 {
14575 if (temp2)
14576 delete arg2;
14577 }
14578 return NULL;
14579 }
14580
14581
14582 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14583 PyObject *resultobj;
14584 wxDC *arg1 = (wxDC *) 0 ;
14585 PyObject * obj0 = 0 ;
14586 char *kwnames[] = {
14587 (char *) "self", NULL
14588 };
14589
14590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
14591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14592 if (SWIG_arg_fail(1)) SWIG_fail;
14593 {
14594 PyThreadState* __tstate = wxPyBeginAllowThreads();
14595 (arg1)->EndDoc();
14596
14597 wxPyEndAllowThreads(__tstate);
14598 if (PyErr_Occurred()) SWIG_fail;
14599 }
14600 Py_INCREF(Py_None); resultobj = Py_None;
14601 return resultobj;
14602 fail:
14603 return NULL;
14604 }
14605
14606
14607 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
14608 PyObject *resultobj;
14609 wxDC *arg1 = (wxDC *) 0 ;
14610 PyObject * obj0 = 0 ;
14611 char *kwnames[] = {
14612 (char *) "self", NULL
14613 };
14614
14615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
14616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14617 if (SWIG_arg_fail(1)) SWIG_fail;
14618 {
14619 PyThreadState* __tstate = wxPyBeginAllowThreads();
14620 (arg1)->StartPage();
14621
14622 wxPyEndAllowThreads(__tstate);
14623 if (PyErr_Occurred()) SWIG_fail;
14624 }
14625 Py_INCREF(Py_None); resultobj = Py_None;
14626 return resultobj;
14627 fail:
14628 return NULL;
14629 }
14630
14631
14632 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
14633 PyObject *resultobj;
14634 wxDC *arg1 = (wxDC *) 0 ;
14635 PyObject * obj0 = 0 ;
14636 char *kwnames[] = {
14637 (char *) "self", NULL
14638 };
14639
14640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
14641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14642 if (SWIG_arg_fail(1)) SWIG_fail;
14643 {
14644 PyThreadState* __tstate = wxPyBeginAllowThreads();
14645 (arg1)->EndPage();
14646
14647 wxPyEndAllowThreads(__tstate);
14648 if (PyErr_Occurred()) SWIG_fail;
14649 }
14650 Py_INCREF(Py_None); resultobj = Py_None;
14651 return resultobj;
14652 fail:
14653 return NULL;
14654 }
14655
14656
14657 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
14658 PyObject *resultobj;
14659 wxDC *arg1 = (wxDC *) 0 ;
14660 wxFont *arg2 = 0 ;
14661 PyObject * obj0 = 0 ;
14662 PyObject * obj1 = 0 ;
14663 char *kwnames[] = {
14664 (char *) "self",(char *) "font", NULL
14665 };
14666
14667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
14668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14669 if (SWIG_arg_fail(1)) SWIG_fail;
14670 {
14671 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14672 if (SWIG_arg_fail(2)) SWIG_fail;
14673 if (arg2 == NULL) {
14674 SWIG_null_ref("wxFont");
14675 }
14676 if (SWIG_arg_fail(2)) SWIG_fail;
14677 }
14678 {
14679 PyThreadState* __tstate = wxPyBeginAllowThreads();
14680 (arg1)->SetFont((wxFont const &)*arg2);
14681
14682 wxPyEndAllowThreads(__tstate);
14683 if (PyErr_Occurred()) SWIG_fail;
14684 }
14685 Py_INCREF(Py_None); resultobj = Py_None;
14686 return resultobj;
14687 fail:
14688 return NULL;
14689 }
14690
14691
14692 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
14693 PyObject *resultobj;
14694 wxDC *arg1 = (wxDC *) 0 ;
14695 wxPen *arg2 = 0 ;
14696 PyObject * obj0 = 0 ;
14697 PyObject * obj1 = 0 ;
14698 char *kwnames[] = {
14699 (char *) "self",(char *) "pen", NULL
14700 };
14701
14702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
14703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14704 if (SWIG_arg_fail(1)) SWIG_fail;
14705 {
14706 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
14707 if (SWIG_arg_fail(2)) SWIG_fail;
14708 if (arg2 == NULL) {
14709 SWIG_null_ref("wxPen");
14710 }
14711 if (SWIG_arg_fail(2)) SWIG_fail;
14712 }
14713 {
14714 PyThreadState* __tstate = wxPyBeginAllowThreads();
14715 (arg1)->SetPen((wxPen const &)*arg2);
14716
14717 wxPyEndAllowThreads(__tstate);
14718 if (PyErr_Occurred()) SWIG_fail;
14719 }
14720 Py_INCREF(Py_None); resultobj = Py_None;
14721 return resultobj;
14722 fail:
14723 return NULL;
14724 }
14725
14726
14727 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
14728 PyObject *resultobj;
14729 wxDC *arg1 = (wxDC *) 0 ;
14730 wxBrush *arg2 = 0 ;
14731 PyObject * obj0 = 0 ;
14732 PyObject * obj1 = 0 ;
14733 char *kwnames[] = {
14734 (char *) "self",(char *) "brush", NULL
14735 };
14736
14737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
14738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14739 if (SWIG_arg_fail(1)) SWIG_fail;
14740 {
14741 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14742 if (SWIG_arg_fail(2)) SWIG_fail;
14743 if (arg2 == NULL) {
14744 SWIG_null_ref("wxBrush");
14745 }
14746 if (SWIG_arg_fail(2)) SWIG_fail;
14747 }
14748 {
14749 PyThreadState* __tstate = wxPyBeginAllowThreads();
14750 (arg1)->SetBrush((wxBrush const &)*arg2);
14751
14752 wxPyEndAllowThreads(__tstate);
14753 if (PyErr_Occurred()) SWIG_fail;
14754 }
14755 Py_INCREF(Py_None); resultobj = Py_None;
14756 return resultobj;
14757 fail:
14758 return NULL;
14759 }
14760
14761
14762 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
14763 PyObject *resultobj;
14764 wxDC *arg1 = (wxDC *) 0 ;
14765 wxBrush *arg2 = 0 ;
14766 PyObject * obj0 = 0 ;
14767 PyObject * obj1 = 0 ;
14768 char *kwnames[] = {
14769 (char *) "self",(char *) "brush", NULL
14770 };
14771
14772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
14773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14774 if (SWIG_arg_fail(1)) SWIG_fail;
14775 {
14776 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14777 if (SWIG_arg_fail(2)) SWIG_fail;
14778 if (arg2 == NULL) {
14779 SWIG_null_ref("wxBrush");
14780 }
14781 if (SWIG_arg_fail(2)) SWIG_fail;
14782 }
14783 {
14784 PyThreadState* __tstate = wxPyBeginAllowThreads();
14785 (arg1)->SetBackground((wxBrush const &)*arg2);
14786
14787 wxPyEndAllowThreads(__tstate);
14788 if (PyErr_Occurred()) SWIG_fail;
14789 }
14790 Py_INCREF(Py_None); resultobj = Py_None;
14791 return resultobj;
14792 fail:
14793 return NULL;
14794 }
14795
14796
14797 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
14798 PyObject *resultobj;
14799 wxDC *arg1 = (wxDC *) 0 ;
14800 int arg2 ;
14801 PyObject * obj0 = 0 ;
14802 PyObject * obj1 = 0 ;
14803 char *kwnames[] = {
14804 (char *) "self",(char *) "mode", NULL
14805 };
14806
14807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
14808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14809 if (SWIG_arg_fail(1)) SWIG_fail;
14810 {
14811 arg2 = (int)(SWIG_As_int(obj1));
14812 if (SWIG_arg_fail(2)) SWIG_fail;
14813 }
14814 {
14815 PyThreadState* __tstate = wxPyBeginAllowThreads();
14816 (arg1)->SetBackgroundMode(arg2);
14817
14818 wxPyEndAllowThreads(__tstate);
14819 if (PyErr_Occurred()) SWIG_fail;
14820 }
14821 Py_INCREF(Py_None); resultobj = Py_None;
14822 return resultobj;
14823 fail:
14824 return NULL;
14825 }
14826
14827
14828 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
14829 PyObject *resultobj;
14830 wxDC *arg1 = (wxDC *) 0 ;
14831 wxPalette *arg2 = 0 ;
14832 PyObject * obj0 = 0 ;
14833 PyObject * obj1 = 0 ;
14834 char *kwnames[] = {
14835 (char *) "self",(char *) "palette", NULL
14836 };
14837
14838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
14839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14840 if (SWIG_arg_fail(1)) SWIG_fail;
14841 {
14842 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
14843 if (SWIG_arg_fail(2)) SWIG_fail;
14844 if (arg2 == NULL) {
14845 SWIG_null_ref("wxPalette");
14846 }
14847 if (SWIG_arg_fail(2)) SWIG_fail;
14848 }
14849 {
14850 PyThreadState* __tstate = wxPyBeginAllowThreads();
14851 (arg1)->SetPalette((wxPalette const &)*arg2);
14852
14853 wxPyEndAllowThreads(__tstate);
14854 if (PyErr_Occurred()) SWIG_fail;
14855 }
14856 Py_INCREF(Py_None); resultobj = Py_None;
14857 return resultobj;
14858 fail:
14859 return NULL;
14860 }
14861
14862
14863 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14864 PyObject *resultobj;
14865 wxDC *arg1 = (wxDC *) 0 ;
14866 PyObject * obj0 = 0 ;
14867 char *kwnames[] = {
14868 (char *) "self", NULL
14869 };
14870
14871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
14872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14873 if (SWIG_arg_fail(1)) SWIG_fail;
14874 {
14875 PyThreadState* __tstate = wxPyBeginAllowThreads();
14876 (arg1)->DestroyClippingRegion();
14877
14878 wxPyEndAllowThreads(__tstate);
14879 if (PyErr_Occurred()) SWIG_fail;
14880 }
14881 Py_INCREF(Py_None); resultobj = Py_None;
14882 return resultobj;
14883 fail:
14884 return NULL;
14885 }
14886
14887
14888 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
14889 PyObject *resultobj;
14890 wxDC *arg1 = (wxDC *) 0 ;
14891 int *arg2 = (int *) 0 ;
14892 int *arg3 = (int *) 0 ;
14893 int *arg4 = (int *) 0 ;
14894 int *arg5 = (int *) 0 ;
14895 int temp2 ;
14896 int res2 = 0 ;
14897 int temp3 ;
14898 int res3 = 0 ;
14899 int temp4 ;
14900 int res4 = 0 ;
14901 int temp5 ;
14902 int res5 = 0 ;
14903 PyObject * obj0 = 0 ;
14904 char *kwnames[] = {
14905 (char *) "self", NULL
14906 };
14907
14908 arg2 = &temp2; res2 = SWIG_NEWOBJ;
14909 arg3 = &temp3; res3 = SWIG_NEWOBJ;
14910 arg4 = &temp4; res4 = SWIG_NEWOBJ;
14911 arg5 = &temp5; res5 = SWIG_NEWOBJ;
14912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
14913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14914 if (SWIG_arg_fail(1)) SWIG_fail;
14915 {
14916 PyThreadState* __tstate = wxPyBeginAllowThreads();
14917 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
14918
14919 wxPyEndAllowThreads(__tstate);
14920 if (PyErr_Occurred()) SWIG_fail;
14921 }
14922 Py_INCREF(Py_None); resultobj = Py_None;
14923 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
14924 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
14925 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
14926 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
14927 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
14928 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
14929 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
14930 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
14931 return resultobj;
14932 fail:
14933 return NULL;
14934 }
14935
14936
14937 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14938 PyObject *resultobj;
14939 wxDC *arg1 = (wxDC *) 0 ;
14940 wxRect result;
14941 PyObject * obj0 = 0 ;
14942 char *kwnames[] = {
14943 (char *) "self", NULL
14944 };
14945
14946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
14947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14948 if (SWIG_arg_fail(1)) SWIG_fail;
14949 {
14950 PyThreadState* __tstate = wxPyBeginAllowThreads();
14951 result = wxDC_GetClippingRect(arg1);
14952
14953 wxPyEndAllowThreads(__tstate);
14954 if (PyErr_Occurred()) SWIG_fail;
14955 }
14956 {
14957 wxRect * resultptr;
14958 resultptr = new wxRect((wxRect &)(result));
14959 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14960 }
14961 return resultobj;
14962 fail:
14963 return NULL;
14964 }
14965
14966
14967 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14968 PyObject *resultobj;
14969 wxDC *arg1 = (wxDC *) 0 ;
14970 int result;
14971 PyObject * obj0 = 0 ;
14972 char *kwnames[] = {
14973 (char *) "self", NULL
14974 };
14975
14976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
14977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14978 if (SWIG_arg_fail(1)) SWIG_fail;
14979 {
14980 PyThreadState* __tstate = wxPyBeginAllowThreads();
14981 result = (int)((wxDC const *)arg1)->GetCharHeight();
14982
14983 wxPyEndAllowThreads(__tstate);
14984 if (PyErr_Occurred()) SWIG_fail;
14985 }
14986 {
14987 resultobj = SWIG_From_int((int)(result));
14988 }
14989 return resultobj;
14990 fail:
14991 return NULL;
14992 }
14993
14994
14995 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14996 PyObject *resultobj;
14997 wxDC *arg1 = (wxDC *) 0 ;
14998 int result;
14999 PyObject * obj0 = 0 ;
15000 char *kwnames[] = {
15001 (char *) "self", NULL
15002 };
15003
15004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
15005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15006 if (SWIG_arg_fail(1)) SWIG_fail;
15007 {
15008 PyThreadState* __tstate = wxPyBeginAllowThreads();
15009 result = (int)((wxDC const *)arg1)->GetCharWidth();
15010
15011 wxPyEndAllowThreads(__tstate);
15012 if (PyErr_Occurred()) SWIG_fail;
15013 }
15014 {
15015 resultobj = SWIG_From_int((int)(result));
15016 }
15017 return resultobj;
15018 fail:
15019 return NULL;
15020 }
15021
15022
15023 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15024 PyObject *resultobj;
15025 wxDC *arg1 = (wxDC *) 0 ;
15026 wxString *arg2 = 0 ;
15027 int *arg3 = (int *) 0 ;
15028 int *arg4 = (int *) 0 ;
15029 bool temp2 = false ;
15030 int temp3 ;
15031 int res3 = 0 ;
15032 int temp4 ;
15033 int res4 = 0 ;
15034 PyObject * obj0 = 0 ;
15035 PyObject * obj1 = 0 ;
15036 char *kwnames[] = {
15037 (char *) "self",(char *) "string", NULL
15038 };
15039
15040 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15041 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15044 if (SWIG_arg_fail(1)) SWIG_fail;
15045 {
15046 arg2 = wxString_in_helper(obj1);
15047 if (arg2 == NULL) SWIG_fail;
15048 temp2 = true;
15049 }
15050 {
15051 PyThreadState* __tstate = wxPyBeginAllowThreads();
15052 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15053
15054 wxPyEndAllowThreads(__tstate);
15055 if (PyErr_Occurred()) SWIG_fail;
15056 }
15057 Py_INCREF(Py_None); resultobj = Py_None;
15058 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15059 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15060 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15061 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15062 {
15063 if (temp2)
15064 delete arg2;
15065 }
15066 return resultobj;
15067 fail:
15068 {
15069 if (temp2)
15070 delete arg2;
15071 }
15072 return NULL;
15073 }
15074
15075
15076 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15077 PyObject *resultobj;
15078 wxDC *arg1 = (wxDC *) 0 ;
15079 wxString *arg2 = 0 ;
15080 int *arg3 = (int *) 0 ;
15081 int *arg4 = (int *) 0 ;
15082 int *arg5 = (int *) 0 ;
15083 int *arg6 = (int *) 0 ;
15084 wxFont *arg7 = (wxFont *) NULL ;
15085 bool temp2 = false ;
15086 int temp3 ;
15087 int res3 = 0 ;
15088 int temp4 ;
15089 int res4 = 0 ;
15090 int temp5 ;
15091 int res5 = 0 ;
15092 int temp6 ;
15093 int res6 = 0 ;
15094 PyObject * obj0 = 0 ;
15095 PyObject * obj1 = 0 ;
15096 PyObject * obj2 = 0 ;
15097 char *kwnames[] = {
15098 (char *) "self",(char *) "string",(char *) "font", NULL
15099 };
15100
15101 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15102 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15103 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15104 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = wxString_in_helper(obj1);
15110 if (arg2 == NULL) SWIG_fail;
15111 temp2 = true;
15112 }
15113 if (obj2) {
15114 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15115 if (SWIG_arg_fail(7)) SWIG_fail;
15116 }
15117 {
15118 PyThreadState* __tstate = wxPyBeginAllowThreads();
15119 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15120
15121 wxPyEndAllowThreads(__tstate);
15122 if (PyErr_Occurred()) SWIG_fail;
15123 }
15124 Py_INCREF(Py_None); resultobj = Py_None;
15125 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15126 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15127 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15128 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15129 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15130 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15131 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15132 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15133 {
15134 if (temp2)
15135 delete arg2;
15136 }
15137 return resultobj;
15138 fail:
15139 {
15140 if (temp2)
15141 delete arg2;
15142 }
15143 return NULL;
15144 }
15145
15146
15147 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15148 PyObject *resultobj;
15149 wxDC *arg1 = (wxDC *) 0 ;
15150 wxString *arg2 = 0 ;
15151 int *arg3 = (int *) 0 ;
15152 int *arg4 = (int *) 0 ;
15153 int *arg5 = (int *) 0 ;
15154 wxFont *arg6 = (wxFont *) NULL ;
15155 bool temp2 = false ;
15156 int temp3 ;
15157 int res3 = 0 ;
15158 int temp4 ;
15159 int res4 = 0 ;
15160 int temp5 ;
15161 int res5 = 0 ;
15162 PyObject * obj0 = 0 ;
15163 PyObject * obj1 = 0 ;
15164 PyObject * obj2 = 0 ;
15165 char *kwnames[] = {
15166 (char *) "self",(char *) "text",(char *) "font", NULL
15167 };
15168
15169 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15170 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15171 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15174 if (SWIG_arg_fail(1)) SWIG_fail;
15175 {
15176 arg2 = wxString_in_helper(obj1);
15177 if (arg2 == NULL) SWIG_fail;
15178 temp2 = true;
15179 }
15180 if (obj2) {
15181 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15182 if (SWIG_arg_fail(6)) SWIG_fail;
15183 }
15184 {
15185 PyThreadState* __tstate = wxPyBeginAllowThreads();
15186 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15187
15188 wxPyEndAllowThreads(__tstate);
15189 if (PyErr_Occurred()) SWIG_fail;
15190 }
15191 Py_INCREF(Py_None); resultobj = Py_None;
15192 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15193 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15194 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15195 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15196 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15197 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15198 {
15199 if (temp2)
15200 delete arg2;
15201 }
15202 return resultobj;
15203 fail:
15204 {
15205 if (temp2)
15206 delete arg2;
15207 }
15208 return NULL;
15209 }
15210
15211
15212 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15213 PyObject *resultobj;
15214 wxDC *arg1 = (wxDC *) 0 ;
15215 wxString *arg2 = 0 ;
15216 wxArrayInt result;
15217 bool temp2 = false ;
15218 PyObject * obj0 = 0 ;
15219 PyObject * obj1 = 0 ;
15220 char *kwnames[] = {
15221 (char *) "self",(char *) "text", NULL
15222 };
15223
15224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15226 if (SWIG_arg_fail(1)) SWIG_fail;
15227 {
15228 arg2 = wxString_in_helper(obj1);
15229 if (arg2 == NULL) SWIG_fail;
15230 temp2 = true;
15231 }
15232 {
15233 PyThreadState* __tstate = wxPyBeginAllowThreads();
15234 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15235
15236 wxPyEndAllowThreads(__tstate);
15237 if (PyErr_Occurred()) SWIG_fail;
15238 }
15239 {
15240 resultobj = PyList_New(0);
15241 size_t idx;
15242 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15243 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15244 PyList_Append(resultobj, val);
15245 Py_DECREF(val);
15246 }
15247 }
15248 {
15249 if (temp2)
15250 delete arg2;
15251 }
15252 return resultobj;
15253 fail:
15254 {
15255 if (temp2)
15256 delete arg2;
15257 }
15258 return NULL;
15259 }
15260
15261
15262 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15263 PyObject *resultobj;
15264 wxDC *arg1 = (wxDC *) 0 ;
15265 wxSize result;
15266 PyObject * obj0 = 0 ;
15267 char *kwnames[] = {
15268 (char *) "self", NULL
15269 };
15270
15271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15273 if (SWIG_arg_fail(1)) SWIG_fail;
15274 {
15275 PyThreadState* __tstate = wxPyBeginAllowThreads();
15276 result = (arg1)->GetSize();
15277
15278 wxPyEndAllowThreads(__tstate);
15279 if (PyErr_Occurred()) SWIG_fail;
15280 }
15281 {
15282 wxSize * resultptr;
15283 resultptr = new wxSize((wxSize &)(result));
15284 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15285 }
15286 return resultobj;
15287 fail:
15288 return NULL;
15289 }
15290
15291
15292 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15293 PyObject *resultobj;
15294 wxDC *arg1 = (wxDC *) 0 ;
15295 int *arg2 = (int *) 0 ;
15296 int *arg3 = (int *) 0 ;
15297 int temp2 ;
15298 int res2 = 0 ;
15299 int temp3 ;
15300 int res3 = 0 ;
15301 PyObject * obj0 = 0 ;
15302 char *kwnames[] = {
15303 (char *) "self", NULL
15304 };
15305
15306 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15307 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15310 if (SWIG_arg_fail(1)) SWIG_fail;
15311 {
15312 PyThreadState* __tstate = wxPyBeginAllowThreads();
15313 (arg1)->GetSize(arg2,arg3);
15314
15315 wxPyEndAllowThreads(__tstate);
15316 if (PyErr_Occurred()) SWIG_fail;
15317 }
15318 Py_INCREF(Py_None); resultobj = Py_None;
15319 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15320 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15321 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15322 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15323 return resultobj;
15324 fail:
15325 return NULL;
15326 }
15327
15328
15329 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15330 PyObject *resultobj;
15331 wxDC *arg1 = (wxDC *) 0 ;
15332 wxSize result;
15333 PyObject * obj0 = 0 ;
15334 char *kwnames[] = {
15335 (char *) "self", NULL
15336 };
15337
15338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
15339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15340 if (SWIG_arg_fail(1)) SWIG_fail;
15341 {
15342 PyThreadState* __tstate = wxPyBeginAllowThreads();
15343 result = ((wxDC const *)arg1)->GetSizeMM();
15344
15345 wxPyEndAllowThreads(__tstate);
15346 if (PyErr_Occurred()) SWIG_fail;
15347 }
15348 {
15349 wxSize * resultptr;
15350 resultptr = new wxSize((wxSize &)(result));
15351 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15352 }
15353 return resultobj;
15354 fail:
15355 return NULL;
15356 }
15357
15358
15359 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15360 PyObject *resultobj;
15361 wxDC *arg1 = (wxDC *) 0 ;
15362 int *arg2 = (int *) 0 ;
15363 int *arg3 = (int *) 0 ;
15364 int temp2 ;
15365 int res2 = 0 ;
15366 int temp3 ;
15367 int res3 = 0 ;
15368 PyObject * obj0 = 0 ;
15369 char *kwnames[] = {
15370 (char *) "self", NULL
15371 };
15372
15373 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15374 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
15376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15377 if (SWIG_arg_fail(1)) SWIG_fail;
15378 {
15379 PyThreadState* __tstate = wxPyBeginAllowThreads();
15380 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
15381
15382 wxPyEndAllowThreads(__tstate);
15383 if (PyErr_Occurred()) SWIG_fail;
15384 }
15385 Py_INCREF(Py_None); resultobj = Py_None;
15386 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15387 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15388 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15389 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15390 return resultobj;
15391 fail:
15392 return NULL;
15393 }
15394
15395
15396 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
15397 PyObject *resultobj;
15398 wxDC *arg1 = (wxDC *) 0 ;
15399 int arg2 ;
15400 int result;
15401 PyObject * obj0 = 0 ;
15402 PyObject * obj1 = 0 ;
15403 char *kwnames[] = {
15404 (char *) "self",(char *) "x", NULL
15405 };
15406
15407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
15408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15409 if (SWIG_arg_fail(1)) SWIG_fail;
15410 {
15411 arg2 = (int)(SWIG_As_int(obj1));
15412 if (SWIG_arg_fail(2)) SWIG_fail;
15413 }
15414 {
15415 PyThreadState* __tstate = wxPyBeginAllowThreads();
15416 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
15417
15418 wxPyEndAllowThreads(__tstate);
15419 if (PyErr_Occurred()) SWIG_fail;
15420 }
15421 {
15422 resultobj = SWIG_From_int((int)(result));
15423 }
15424 return resultobj;
15425 fail:
15426 return NULL;
15427 }
15428
15429
15430 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
15431 PyObject *resultobj;
15432 wxDC *arg1 = (wxDC *) 0 ;
15433 int arg2 ;
15434 int result;
15435 PyObject * obj0 = 0 ;
15436 PyObject * obj1 = 0 ;
15437 char *kwnames[] = {
15438 (char *) "self",(char *) "y", NULL
15439 };
15440
15441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
15442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15443 if (SWIG_arg_fail(1)) SWIG_fail;
15444 {
15445 arg2 = (int)(SWIG_As_int(obj1));
15446 if (SWIG_arg_fail(2)) SWIG_fail;
15447 }
15448 {
15449 PyThreadState* __tstate = wxPyBeginAllowThreads();
15450 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
15451
15452 wxPyEndAllowThreads(__tstate);
15453 if (PyErr_Occurred()) SWIG_fail;
15454 }
15455 {
15456 resultobj = SWIG_From_int((int)(result));
15457 }
15458 return resultobj;
15459 fail:
15460 return NULL;
15461 }
15462
15463
15464 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15465 PyObject *resultobj;
15466 wxDC *arg1 = (wxDC *) 0 ;
15467 int arg2 ;
15468 int result;
15469 PyObject * obj0 = 0 ;
15470 PyObject * obj1 = 0 ;
15471 char *kwnames[] = {
15472 (char *) "self",(char *) "x", NULL
15473 };
15474
15475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
15476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15477 if (SWIG_arg_fail(1)) SWIG_fail;
15478 {
15479 arg2 = (int)(SWIG_As_int(obj1));
15480 if (SWIG_arg_fail(2)) SWIG_fail;
15481 }
15482 {
15483 PyThreadState* __tstate = wxPyBeginAllowThreads();
15484 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
15485
15486 wxPyEndAllowThreads(__tstate);
15487 if (PyErr_Occurred()) SWIG_fail;
15488 }
15489 {
15490 resultobj = SWIG_From_int((int)(result));
15491 }
15492 return resultobj;
15493 fail:
15494 return NULL;
15495 }
15496
15497
15498 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15499 PyObject *resultobj;
15500 wxDC *arg1 = (wxDC *) 0 ;
15501 int arg2 ;
15502 int result;
15503 PyObject * obj0 = 0 ;
15504 PyObject * obj1 = 0 ;
15505 char *kwnames[] = {
15506 (char *) "self",(char *) "y", NULL
15507 };
15508
15509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
15510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15511 if (SWIG_arg_fail(1)) SWIG_fail;
15512 {
15513 arg2 = (int)(SWIG_As_int(obj1));
15514 if (SWIG_arg_fail(2)) SWIG_fail;
15515 }
15516 {
15517 PyThreadState* __tstate = wxPyBeginAllowThreads();
15518 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
15519
15520 wxPyEndAllowThreads(__tstate);
15521 if (PyErr_Occurred()) SWIG_fail;
15522 }
15523 {
15524 resultobj = SWIG_From_int((int)(result));
15525 }
15526 return resultobj;
15527 fail:
15528 return NULL;
15529 }
15530
15531
15532 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
15533 PyObject *resultobj;
15534 wxDC *arg1 = (wxDC *) 0 ;
15535 int arg2 ;
15536 int result;
15537 PyObject * obj0 = 0 ;
15538 PyObject * obj1 = 0 ;
15539 char *kwnames[] = {
15540 (char *) "self",(char *) "x", NULL
15541 };
15542
15543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
15544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15545 if (SWIG_arg_fail(1)) SWIG_fail;
15546 {
15547 arg2 = (int)(SWIG_As_int(obj1));
15548 if (SWIG_arg_fail(2)) SWIG_fail;
15549 }
15550 {
15551 PyThreadState* __tstate = wxPyBeginAllowThreads();
15552 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
15553
15554 wxPyEndAllowThreads(__tstate);
15555 if (PyErr_Occurred()) SWIG_fail;
15556 }
15557 {
15558 resultobj = SWIG_From_int((int)(result));
15559 }
15560 return resultobj;
15561 fail:
15562 return NULL;
15563 }
15564
15565
15566 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
15567 PyObject *resultobj;
15568 wxDC *arg1 = (wxDC *) 0 ;
15569 int arg2 ;
15570 int result;
15571 PyObject * obj0 = 0 ;
15572 PyObject * obj1 = 0 ;
15573 char *kwnames[] = {
15574 (char *) "self",(char *) "y", NULL
15575 };
15576
15577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
15578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15579 if (SWIG_arg_fail(1)) SWIG_fail;
15580 {
15581 arg2 = (int)(SWIG_As_int(obj1));
15582 if (SWIG_arg_fail(2)) SWIG_fail;
15583 }
15584 {
15585 PyThreadState* __tstate = wxPyBeginAllowThreads();
15586 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
15587
15588 wxPyEndAllowThreads(__tstate);
15589 if (PyErr_Occurred()) SWIG_fail;
15590 }
15591 {
15592 resultobj = SWIG_From_int((int)(result));
15593 }
15594 return resultobj;
15595 fail:
15596 return NULL;
15597 }
15598
15599
15600 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15601 PyObject *resultobj;
15602 wxDC *arg1 = (wxDC *) 0 ;
15603 int arg2 ;
15604 int result;
15605 PyObject * obj0 = 0 ;
15606 PyObject * obj1 = 0 ;
15607 char *kwnames[] = {
15608 (char *) "self",(char *) "x", NULL
15609 };
15610
15611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
15612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15613 if (SWIG_arg_fail(1)) SWIG_fail;
15614 {
15615 arg2 = (int)(SWIG_As_int(obj1));
15616 if (SWIG_arg_fail(2)) SWIG_fail;
15617 }
15618 {
15619 PyThreadState* __tstate = wxPyBeginAllowThreads();
15620 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
15621
15622 wxPyEndAllowThreads(__tstate);
15623 if (PyErr_Occurred()) SWIG_fail;
15624 }
15625 {
15626 resultobj = SWIG_From_int((int)(result));
15627 }
15628 return resultobj;
15629 fail:
15630 return NULL;
15631 }
15632
15633
15634 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15635 PyObject *resultobj;
15636 wxDC *arg1 = (wxDC *) 0 ;
15637 int arg2 ;
15638 int result;
15639 PyObject * obj0 = 0 ;
15640 PyObject * obj1 = 0 ;
15641 char *kwnames[] = {
15642 (char *) "self",(char *) "y", NULL
15643 };
15644
15645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
15646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15647 if (SWIG_arg_fail(1)) SWIG_fail;
15648 {
15649 arg2 = (int)(SWIG_As_int(obj1));
15650 if (SWIG_arg_fail(2)) SWIG_fail;
15651 }
15652 {
15653 PyThreadState* __tstate = wxPyBeginAllowThreads();
15654 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
15655
15656 wxPyEndAllowThreads(__tstate);
15657 if (PyErr_Occurred()) SWIG_fail;
15658 }
15659 {
15660 resultobj = SWIG_From_int((int)(result));
15661 }
15662 return resultobj;
15663 fail:
15664 return NULL;
15665 }
15666
15667
15668 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
15669 PyObject *resultobj;
15670 wxDC *arg1 = (wxDC *) 0 ;
15671 bool result;
15672 PyObject * obj0 = 0 ;
15673 char *kwnames[] = {
15674 (char *) "self", NULL
15675 };
15676
15677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
15678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15679 if (SWIG_arg_fail(1)) SWIG_fail;
15680 {
15681 PyThreadState* __tstate = wxPyBeginAllowThreads();
15682 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
15683
15684 wxPyEndAllowThreads(__tstate);
15685 if (PyErr_Occurred()) SWIG_fail;
15686 }
15687 {
15688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15689 }
15690 return resultobj;
15691 fail:
15692 return NULL;
15693 }
15694
15695
15696 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15697 PyObject *resultobj;
15698 wxDC *arg1 = (wxDC *) 0 ;
15699 bool result;
15700 PyObject * obj0 = 0 ;
15701 char *kwnames[] = {
15702 (char *) "self", NULL
15703 };
15704
15705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
15706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15707 if (SWIG_arg_fail(1)) SWIG_fail;
15708 {
15709 PyThreadState* __tstate = wxPyBeginAllowThreads();
15710 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
15711
15712 wxPyEndAllowThreads(__tstate);
15713 if (PyErr_Occurred()) SWIG_fail;
15714 }
15715 {
15716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15717 }
15718 return resultobj;
15719 fail:
15720 return NULL;
15721 }
15722
15723
15724 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
15725 PyObject *resultobj;
15726 wxDC *arg1 = (wxDC *) 0 ;
15727 int result;
15728 PyObject * obj0 = 0 ;
15729 char *kwnames[] = {
15730 (char *) "self", NULL
15731 };
15732
15733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
15734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15735 if (SWIG_arg_fail(1)) SWIG_fail;
15736 {
15737 PyThreadState* __tstate = wxPyBeginAllowThreads();
15738 result = (int)((wxDC const *)arg1)->GetDepth();
15739
15740 wxPyEndAllowThreads(__tstate);
15741 if (PyErr_Occurred()) SWIG_fail;
15742 }
15743 {
15744 resultobj = SWIG_From_int((int)(result));
15745 }
15746 return resultobj;
15747 fail:
15748 return NULL;
15749 }
15750
15751
15752 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
15753 PyObject *resultobj;
15754 wxDC *arg1 = (wxDC *) 0 ;
15755 wxSize result;
15756 PyObject * obj0 = 0 ;
15757 char *kwnames[] = {
15758 (char *) "self", NULL
15759 };
15760
15761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
15762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15763 if (SWIG_arg_fail(1)) SWIG_fail;
15764 {
15765 PyThreadState* __tstate = wxPyBeginAllowThreads();
15766 result = ((wxDC const *)arg1)->GetPPI();
15767
15768 wxPyEndAllowThreads(__tstate);
15769 if (PyErr_Occurred()) SWIG_fail;
15770 }
15771 {
15772 wxSize * resultptr;
15773 resultptr = new wxSize((wxSize &)(result));
15774 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15775 }
15776 return resultobj;
15777 fail:
15778 return NULL;
15779 }
15780
15781
15782 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
15783 PyObject *resultobj;
15784 wxDC *arg1 = (wxDC *) 0 ;
15785 bool result;
15786 PyObject * obj0 = 0 ;
15787 char *kwnames[] = {
15788 (char *) "self", NULL
15789 };
15790
15791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
15796 result = (bool)((wxDC const *)arg1)->Ok();
15797
15798 wxPyEndAllowThreads(__tstate);
15799 if (PyErr_Occurred()) SWIG_fail;
15800 }
15801 {
15802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15803 }
15804 return resultobj;
15805 fail:
15806 return NULL;
15807 }
15808
15809
15810 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15811 PyObject *resultobj;
15812 wxDC *arg1 = (wxDC *) 0 ;
15813 int result;
15814 PyObject * obj0 = 0 ;
15815 char *kwnames[] = {
15816 (char *) "self", NULL
15817 };
15818
15819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
15820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15821 if (SWIG_arg_fail(1)) SWIG_fail;
15822 {
15823 PyThreadState* __tstate = wxPyBeginAllowThreads();
15824 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
15825
15826 wxPyEndAllowThreads(__tstate);
15827 if (PyErr_Occurred()) SWIG_fail;
15828 }
15829 {
15830 resultobj = SWIG_From_int((int)(result));
15831 }
15832 return resultobj;
15833 fail:
15834 return NULL;
15835 }
15836
15837
15838 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15839 PyObject *resultobj;
15840 wxDC *arg1 = (wxDC *) 0 ;
15841 wxBrush *result;
15842 PyObject * obj0 = 0 ;
15843 char *kwnames[] = {
15844 (char *) "self", NULL
15845 };
15846
15847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
15848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15849 if (SWIG_arg_fail(1)) SWIG_fail;
15850 {
15851 PyThreadState* __tstate = wxPyBeginAllowThreads();
15852 {
15853 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
15854 result = (wxBrush *) &_result_ref;
15855 }
15856
15857 wxPyEndAllowThreads(__tstate);
15858 if (PyErr_Occurred()) SWIG_fail;
15859 }
15860 {
15861 wxBrush* resultptr = new wxBrush(*result);
15862 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15863 }
15864 return resultobj;
15865 fail:
15866 return NULL;
15867 }
15868
15869
15870 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15871 PyObject *resultobj;
15872 wxDC *arg1 = (wxDC *) 0 ;
15873 wxBrush *result;
15874 PyObject * obj0 = 0 ;
15875 char *kwnames[] = {
15876 (char *) "self", NULL
15877 };
15878
15879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
15880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15881 if (SWIG_arg_fail(1)) SWIG_fail;
15882 {
15883 PyThreadState* __tstate = wxPyBeginAllowThreads();
15884 {
15885 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
15886 result = (wxBrush *) &_result_ref;
15887 }
15888
15889 wxPyEndAllowThreads(__tstate);
15890 if (PyErr_Occurred()) SWIG_fail;
15891 }
15892 {
15893 wxBrush* resultptr = new wxBrush(*result);
15894 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15895 }
15896 return resultobj;
15897 fail:
15898 return NULL;
15899 }
15900
15901
15902 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15903 PyObject *resultobj;
15904 wxDC *arg1 = (wxDC *) 0 ;
15905 wxFont *result;
15906 PyObject * obj0 = 0 ;
15907 char *kwnames[] = {
15908 (char *) "self", NULL
15909 };
15910
15911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
15912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15913 if (SWIG_arg_fail(1)) SWIG_fail;
15914 {
15915 PyThreadState* __tstate = wxPyBeginAllowThreads();
15916 {
15917 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
15918 result = (wxFont *) &_result_ref;
15919 }
15920
15921 wxPyEndAllowThreads(__tstate);
15922 if (PyErr_Occurred()) SWIG_fail;
15923 }
15924 {
15925 wxFont* resultptr = new wxFont(*result);
15926 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
15927 }
15928 return resultobj;
15929 fail:
15930 return NULL;
15931 }
15932
15933
15934 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
15935 PyObject *resultobj;
15936 wxDC *arg1 = (wxDC *) 0 ;
15937 wxPen *result;
15938 PyObject * obj0 = 0 ;
15939 char *kwnames[] = {
15940 (char *) "self", NULL
15941 };
15942
15943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
15944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15945 if (SWIG_arg_fail(1)) SWIG_fail;
15946 {
15947 PyThreadState* __tstate = wxPyBeginAllowThreads();
15948 {
15949 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
15950 result = (wxPen *) &_result_ref;
15951 }
15952
15953 wxPyEndAllowThreads(__tstate);
15954 if (PyErr_Occurred()) SWIG_fail;
15955 }
15956 {
15957 wxPen* resultptr = new wxPen(*result);
15958 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
15959 }
15960 return resultobj;
15961 fail:
15962 return NULL;
15963 }
15964
15965
15966 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15967 PyObject *resultobj;
15968 wxDC *arg1 = (wxDC *) 0 ;
15969 wxColour *result;
15970 PyObject * obj0 = 0 ;
15971 char *kwnames[] = {
15972 (char *) "self", NULL
15973 };
15974
15975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
15976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15977 if (SWIG_arg_fail(1)) SWIG_fail;
15978 {
15979 PyThreadState* __tstate = wxPyBeginAllowThreads();
15980 {
15981 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
15982 result = (wxColour *) &_result_ref;
15983 }
15984
15985 wxPyEndAllowThreads(__tstate);
15986 if (PyErr_Occurred()) SWIG_fail;
15987 }
15988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
15989 return resultobj;
15990 fail:
15991 return NULL;
15992 }
15993
15994
15995 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
15996 PyObject *resultobj;
15997 wxDC *arg1 = (wxDC *) 0 ;
15998 wxColour *result;
15999 PyObject * obj0 = 0 ;
16000 char *kwnames[] = {
16001 (char *) "self", NULL
16002 };
16003
16004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
16005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16006 if (SWIG_arg_fail(1)) SWIG_fail;
16007 {
16008 PyThreadState* __tstate = wxPyBeginAllowThreads();
16009 {
16010 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
16011 result = (wxColour *) &_result_ref;
16012 }
16013
16014 wxPyEndAllowThreads(__tstate);
16015 if (PyErr_Occurred()) SWIG_fail;
16016 }
16017 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16018 return resultobj;
16019 fail:
16020 return NULL;
16021 }
16022
16023
16024 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16025 PyObject *resultobj;
16026 wxDC *arg1 = (wxDC *) 0 ;
16027 wxColour *arg2 = 0 ;
16028 wxColour temp2 ;
16029 PyObject * obj0 = 0 ;
16030 PyObject * obj1 = 0 ;
16031 char *kwnames[] = {
16032 (char *) "self",(char *) "colour", NULL
16033 };
16034
16035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16037 if (SWIG_arg_fail(1)) SWIG_fail;
16038 {
16039 arg2 = &temp2;
16040 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16041 }
16042 {
16043 PyThreadState* __tstate = wxPyBeginAllowThreads();
16044 (arg1)->SetTextForeground((wxColour const &)*arg2);
16045
16046 wxPyEndAllowThreads(__tstate);
16047 if (PyErr_Occurred()) SWIG_fail;
16048 }
16049 Py_INCREF(Py_None); resultobj = Py_None;
16050 return resultobj;
16051 fail:
16052 return NULL;
16053 }
16054
16055
16056 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16057 PyObject *resultobj;
16058 wxDC *arg1 = (wxDC *) 0 ;
16059 wxColour *arg2 = 0 ;
16060 wxColour temp2 ;
16061 PyObject * obj0 = 0 ;
16062 PyObject * obj1 = 0 ;
16063 char *kwnames[] = {
16064 (char *) "self",(char *) "colour", NULL
16065 };
16066
16067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16069 if (SWIG_arg_fail(1)) SWIG_fail;
16070 {
16071 arg2 = &temp2;
16072 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16073 }
16074 {
16075 PyThreadState* __tstate = wxPyBeginAllowThreads();
16076 (arg1)->SetTextBackground((wxColour const &)*arg2);
16077
16078 wxPyEndAllowThreads(__tstate);
16079 if (PyErr_Occurred()) SWIG_fail;
16080 }
16081 Py_INCREF(Py_None); resultobj = Py_None;
16082 return resultobj;
16083 fail:
16084 return NULL;
16085 }
16086
16087
16088 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16089 PyObject *resultobj;
16090 wxDC *arg1 = (wxDC *) 0 ;
16091 int result;
16092 PyObject * obj0 = 0 ;
16093 char *kwnames[] = {
16094 (char *) "self", NULL
16095 };
16096
16097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16099 if (SWIG_arg_fail(1)) SWIG_fail;
16100 {
16101 PyThreadState* __tstate = wxPyBeginAllowThreads();
16102 result = (int)((wxDC const *)arg1)->GetMapMode();
16103
16104 wxPyEndAllowThreads(__tstate);
16105 if (PyErr_Occurred()) SWIG_fail;
16106 }
16107 {
16108 resultobj = SWIG_From_int((int)(result));
16109 }
16110 return resultobj;
16111 fail:
16112 return NULL;
16113 }
16114
16115
16116 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16117 PyObject *resultobj;
16118 wxDC *arg1 = (wxDC *) 0 ;
16119 int arg2 ;
16120 PyObject * obj0 = 0 ;
16121 PyObject * obj1 = 0 ;
16122 char *kwnames[] = {
16123 (char *) "self",(char *) "mode", NULL
16124 };
16125
16126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16128 if (SWIG_arg_fail(1)) SWIG_fail;
16129 {
16130 arg2 = (int)(SWIG_As_int(obj1));
16131 if (SWIG_arg_fail(2)) SWIG_fail;
16132 }
16133 {
16134 PyThreadState* __tstate = wxPyBeginAllowThreads();
16135 (arg1)->SetMapMode(arg2);
16136
16137 wxPyEndAllowThreads(__tstate);
16138 if (PyErr_Occurred()) SWIG_fail;
16139 }
16140 Py_INCREF(Py_None); resultobj = Py_None;
16141 return resultobj;
16142 fail:
16143 return NULL;
16144 }
16145
16146
16147 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16148 PyObject *resultobj;
16149 wxDC *arg1 = (wxDC *) 0 ;
16150 double *arg2 = (double *) 0 ;
16151 double *arg3 = (double *) 0 ;
16152 double temp2 ;
16153 int res2 = 0 ;
16154 double temp3 ;
16155 int res3 = 0 ;
16156 PyObject * obj0 = 0 ;
16157 char *kwnames[] = {
16158 (char *) "self", NULL
16159 };
16160
16161 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16162 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16165 if (SWIG_arg_fail(1)) SWIG_fail;
16166 {
16167 PyThreadState* __tstate = wxPyBeginAllowThreads();
16168 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16169
16170 wxPyEndAllowThreads(__tstate);
16171 if (PyErr_Occurred()) SWIG_fail;
16172 }
16173 Py_INCREF(Py_None); resultobj = Py_None;
16174 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16175 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16176 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16177 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16178 return resultobj;
16179 fail:
16180 return NULL;
16181 }
16182
16183
16184 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16185 PyObject *resultobj;
16186 wxDC *arg1 = (wxDC *) 0 ;
16187 double arg2 ;
16188 double arg3 ;
16189 PyObject * obj0 = 0 ;
16190 PyObject * obj1 = 0 ;
16191 PyObject * obj2 = 0 ;
16192 char *kwnames[] = {
16193 (char *) "self",(char *) "x",(char *) "y", NULL
16194 };
16195
16196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) 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 = (double)(SWIG_As_double(obj1));
16201 if (SWIG_arg_fail(2)) SWIG_fail;
16202 }
16203 {
16204 arg3 = (double)(SWIG_As_double(obj2));
16205 if (SWIG_arg_fail(3)) SWIG_fail;
16206 }
16207 {
16208 PyThreadState* __tstate = wxPyBeginAllowThreads();
16209 (arg1)->SetUserScale(arg2,arg3);
16210
16211 wxPyEndAllowThreads(__tstate);
16212 if (PyErr_Occurred()) SWIG_fail;
16213 }
16214 Py_INCREF(Py_None); resultobj = Py_None;
16215 return resultobj;
16216 fail:
16217 return NULL;
16218 }
16219
16220
16221 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16222 PyObject *resultobj;
16223 wxDC *arg1 = (wxDC *) 0 ;
16224 double *arg2 = (double *) 0 ;
16225 double *arg3 = (double *) 0 ;
16226 double temp2 ;
16227 int res2 = 0 ;
16228 double temp3 ;
16229 int res3 = 0 ;
16230 PyObject * obj0 = 0 ;
16231 char *kwnames[] = {
16232 (char *) "self", NULL
16233 };
16234
16235 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16236 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16239 if (SWIG_arg_fail(1)) SWIG_fail;
16240 {
16241 PyThreadState* __tstate = wxPyBeginAllowThreads();
16242 (arg1)->GetLogicalScale(arg2,arg3);
16243
16244 wxPyEndAllowThreads(__tstate);
16245 if (PyErr_Occurred()) SWIG_fail;
16246 }
16247 Py_INCREF(Py_None); resultobj = Py_None;
16248 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16249 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16250 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16251 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16252 return resultobj;
16253 fail:
16254 return NULL;
16255 }
16256
16257
16258 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16259 PyObject *resultobj;
16260 wxDC *arg1 = (wxDC *) 0 ;
16261 double arg2 ;
16262 double arg3 ;
16263 PyObject * obj0 = 0 ;
16264 PyObject * obj1 = 0 ;
16265 PyObject * obj2 = 0 ;
16266 char *kwnames[] = {
16267 (char *) "self",(char *) "x",(char *) "y", NULL
16268 };
16269
16270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16272 if (SWIG_arg_fail(1)) SWIG_fail;
16273 {
16274 arg2 = (double)(SWIG_As_double(obj1));
16275 if (SWIG_arg_fail(2)) SWIG_fail;
16276 }
16277 {
16278 arg3 = (double)(SWIG_As_double(obj2));
16279 if (SWIG_arg_fail(3)) SWIG_fail;
16280 }
16281 {
16282 PyThreadState* __tstate = wxPyBeginAllowThreads();
16283 (arg1)->SetLogicalScale(arg2,arg3);
16284
16285 wxPyEndAllowThreads(__tstate);
16286 if (PyErr_Occurred()) SWIG_fail;
16287 }
16288 Py_INCREF(Py_None); resultobj = Py_None;
16289 return resultobj;
16290 fail:
16291 return NULL;
16292 }
16293
16294
16295 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16296 PyObject *resultobj;
16297 wxDC *arg1 = (wxDC *) 0 ;
16298 wxPoint result;
16299 PyObject * obj0 = 0 ;
16300 char *kwnames[] = {
16301 (char *) "self", NULL
16302 };
16303
16304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16306 if (SWIG_arg_fail(1)) SWIG_fail;
16307 {
16308 PyThreadState* __tstate = wxPyBeginAllowThreads();
16309 result = ((wxDC const *)arg1)->GetLogicalOrigin();
16310
16311 wxPyEndAllowThreads(__tstate);
16312 if (PyErr_Occurred()) SWIG_fail;
16313 }
16314 {
16315 wxPoint * resultptr;
16316 resultptr = new wxPoint((wxPoint &)(result));
16317 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16318 }
16319 return resultobj;
16320 fail:
16321 return NULL;
16322 }
16323
16324
16325 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16326 PyObject *resultobj;
16327 wxDC *arg1 = (wxDC *) 0 ;
16328 int *arg2 = (int *) 0 ;
16329 int *arg3 = (int *) 0 ;
16330 int temp2 ;
16331 int res2 = 0 ;
16332 int temp3 ;
16333 int res3 = 0 ;
16334 PyObject * obj0 = 0 ;
16335 char *kwnames[] = {
16336 (char *) "self", NULL
16337 };
16338
16339 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16340 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
16342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16343 if (SWIG_arg_fail(1)) SWIG_fail;
16344 {
16345 PyThreadState* __tstate = wxPyBeginAllowThreads();
16346 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
16347
16348 wxPyEndAllowThreads(__tstate);
16349 if (PyErr_Occurred()) SWIG_fail;
16350 }
16351 Py_INCREF(Py_None); resultobj = Py_None;
16352 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16353 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16354 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16355 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16356 return resultobj;
16357 fail:
16358 return NULL;
16359 }
16360
16361
16362 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16363 PyObject *resultobj;
16364 wxDC *arg1 = (wxDC *) 0 ;
16365 int arg2 ;
16366 int arg3 ;
16367 PyObject * obj0 = 0 ;
16368 PyObject * obj1 = 0 ;
16369 PyObject * obj2 = 0 ;
16370 char *kwnames[] = {
16371 (char *) "self",(char *) "x",(char *) "y", NULL
16372 };
16373
16374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16376 if (SWIG_arg_fail(1)) SWIG_fail;
16377 {
16378 arg2 = (int)(SWIG_As_int(obj1));
16379 if (SWIG_arg_fail(2)) SWIG_fail;
16380 }
16381 {
16382 arg3 = (int)(SWIG_As_int(obj2));
16383 if (SWIG_arg_fail(3)) SWIG_fail;
16384 }
16385 {
16386 PyThreadState* __tstate = wxPyBeginAllowThreads();
16387 (arg1)->SetLogicalOrigin(arg2,arg3);
16388
16389 wxPyEndAllowThreads(__tstate);
16390 if (PyErr_Occurred()) SWIG_fail;
16391 }
16392 Py_INCREF(Py_None); resultobj = Py_None;
16393 return resultobj;
16394 fail:
16395 return NULL;
16396 }
16397
16398
16399 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16400 PyObject *resultobj;
16401 wxDC *arg1 = (wxDC *) 0 ;
16402 wxPoint *arg2 = 0 ;
16403 wxPoint temp2 ;
16404 PyObject * obj0 = 0 ;
16405 PyObject * obj1 = 0 ;
16406 char *kwnames[] = {
16407 (char *) "self",(char *) "point", NULL
16408 };
16409
16410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
16415 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16416 }
16417 {
16418 PyThreadState* __tstate = wxPyBeginAllowThreads();
16419 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
16420
16421 wxPyEndAllowThreads(__tstate);
16422 if (PyErr_Occurred()) SWIG_fail;
16423 }
16424 Py_INCREF(Py_None); resultobj = Py_None;
16425 return resultobj;
16426 fail:
16427 return NULL;
16428 }
16429
16430
16431 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16432 PyObject *resultobj;
16433 wxDC *arg1 = (wxDC *) 0 ;
16434 wxPoint result;
16435 PyObject * obj0 = 0 ;
16436 char *kwnames[] = {
16437 (char *) "self", NULL
16438 };
16439
16440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
16441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16442 if (SWIG_arg_fail(1)) SWIG_fail;
16443 {
16444 PyThreadState* __tstate = wxPyBeginAllowThreads();
16445 result = ((wxDC const *)arg1)->GetDeviceOrigin();
16446
16447 wxPyEndAllowThreads(__tstate);
16448 if (PyErr_Occurred()) SWIG_fail;
16449 }
16450 {
16451 wxPoint * resultptr;
16452 resultptr = new wxPoint((wxPoint &)(result));
16453 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16454 }
16455 return resultobj;
16456 fail:
16457 return NULL;
16458 }
16459
16460
16461 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16462 PyObject *resultobj;
16463 wxDC *arg1 = (wxDC *) 0 ;
16464 int *arg2 = (int *) 0 ;
16465 int *arg3 = (int *) 0 ;
16466 int temp2 ;
16467 int res2 = 0 ;
16468 int temp3 ;
16469 int res3 = 0 ;
16470 PyObject * obj0 = 0 ;
16471 char *kwnames[] = {
16472 (char *) "self", NULL
16473 };
16474
16475 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16476 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
16478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16479 if (SWIG_arg_fail(1)) SWIG_fail;
16480 {
16481 PyThreadState* __tstate = wxPyBeginAllowThreads();
16482 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
16483
16484 wxPyEndAllowThreads(__tstate);
16485 if (PyErr_Occurred()) SWIG_fail;
16486 }
16487 Py_INCREF(Py_None); resultobj = Py_None;
16488 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16489 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16490 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16491 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16492 return resultobj;
16493 fail:
16494 return NULL;
16495 }
16496
16497
16498 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16499 PyObject *resultobj;
16500 wxDC *arg1 = (wxDC *) 0 ;
16501 int arg2 ;
16502 int arg3 ;
16503 PyObject * obj0 = 0 ;
16504 PyObject * obj1 = 0 ;
16505 PyObject * obj2 = 0 ;
16506 char *kwnames[] = {
16507 (char *) "self",(char *) "x",(char *) "y", NULL
16508 };
16509
16510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16512 if (SWIG_arg_fail(1)) SWIG_fail;
16513 {
16514 arg2 = (int)(SWIG_As_int(obj1));
16515 if (SWIG_arg_fail(2)) SWIG_fail;
16516 }
16517 {
16518 arg3 = (int)(SWIG_As_int(obj2));
16519 if (SWIG_arg_fail(3)) SWIG_fail;
16520 }
16521 {
16522 PyThreadState* __tstate = wxPyBeginAllowThreads();
16523 (arg1)->SetDeviceOrigin(arg2,arg3);
16524
16525 wxPyEndAllowThreads(__tstate);
16526 if (PyErr_Occurred()) SWIG_fail;
16527 }
16528 Py_INCREF(Py_None); resultobj = Py_None;
16529 return resultobj;
16530 fail:
16531 return NULL;
16532 }
16533
16534
16535 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16536 PyObject *resultobj;
16537 wxDC *arg1 = (wxDC *) 0 ;
16538 wxPoint *arg2 = 0 ;
16539 wxPoint temp2 ;
16540 PyObject * obj0 = 0 ;
16541 PyObject * obj1 = 0 ;
16542 char *kwnames[] = {
16543 (char *) "self",(char *) "point", NULL
16544 };
16545
16546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16548 if (SWIG_arg_fail(1)) SWIG_fail;
16549 {
16550 arg2 = &temp2;
16551 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16552 }
16553 {
16554 PyThreadState* __tstate = wxPyBeginAllowThreads();
16555 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
16556
16557 wxPyEndAllowThreads(__tstate);
16558 if (PyErr_Occurred()) SWIG_fail;
16559 }
16560 Py_INCREF(Py_None); resultobj = Py_None;
16561 return resultobj;
16562 fail:
16563 return NULL;
16564 }
16565
16566
16567 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16568 PyObject *resultobj;
16569 wxDC *arg1 = (wxDC *) 0 ;
16570 bool arg2 ;
16571 bool arg3 ;
16572 PyObject * obj0 = 0 ;
16573 PyObject * obj1 = 0 ;
16574 PyObject * obj2 = 0 ;
16575 char *kwnames[] = {
16576 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
16577 };
16578
16579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
16580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16581 if (SWIG_arg_fail(1)) SWIG_fail;
16582 {
16583 arg2 = (bool)(SWIG_As_bool(obj1));
16584 if (SWIG_arg_fail(2)) SWIG_fail;
16585 }
16586 {
16587 arg3 = (bool)(SWIG_As_bool(obj2));
16588 if (SWIG_arg_fail(3)) SWIG_fail;
16589 }
16590 {
16591 PyThreadState* __tstate = wxPyBeginAllowThreads();
16592 (arg1)->SetAxisOrientation(arg2,arg3);
16593
16594 wxPyEndAllowThreads(__tstate);
16595 if (PyErr_Occurred()) SWIG_fail;
16596 }
16597 Py_INCREF(Py_None); resultobj = Py_None;
16598 return resultobj;
16599 fail:
16600 return NULL;
16601 }
16602
16603
16604 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16605 PyObject *resultobj;
16606 wxDC *arg1 = (wxDC *) 0 ;
16607 int result;
16608 PyObject * obj0 = 0 ;
16609 char *kwnames[] = {
16610 (char *) "self", NULL
16611 };
16612
16613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
16614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16615 if (SWIG_arg_fail(1)) SWIG_fail;
16616 {
16617 PyThreadState* __tstate = wxPyBeginAllowThreads();
16618 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
16619
16620 wxPyEndAllowThreads(__tstate);
16621 if (PyErr_Occurred()) SWIG_fail;
16622 }
16623 {
16624 resultobj = SWIG_From_int((int)(result));
16625 }
16626 return resultobj;
16627 fail:
16628 return NULL;
16629 }
16630
16631
16632 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16633 PyObject *resultobj;
16634 wxDC *arg1 = (wxDC *) 0 ;
16635 int arg2 ;
16636 PyObject * obj0 = 0 ;
16637 PyObject * obj1 = 0 ;
16638 char *kwnames[] = {
16639 (char *) "self",(char *) "function", NULL
16640 };
16641
16642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
16643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16644 if (SWIG_arg_fail(1)) SWIG_fail;
16645 {
16646 arg2 = (int)(SWIG_As_int(obj1));
16647 if (SWIG_arg_fail(2)) SWIG_fail;
16648 }
16649 {
16650 PyThreadState* __tstate = wxPyBeginAllowThreads();
16651 (arg1)->SetLogicalFunction(arg2);
16652
16653 wxPyEndAllowThreads(__tstate);
16654 if (PyErr_Occurred()) SWIG_fail;
16655 }
16656 Py_INCREF(Py_None); resultobj = Py_None;
16657 return resultobj;
16658 fail:
16659 return NULL;
16660 }
16661
16662
16663 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16664 PyObject *resultobj;
16665 wxDC *arg1 = (wxDC *) 0 ;
16666 PyObject * obj0 = 0 ;
16667 char *kwnames[] = {
16668 (char *) "self", NULL
16669 };
16670
16671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
16672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16673 if (SWIG_arg_fail(1)) SWIG_fail;
16674 {
16675 PyThreadState* __tstate = wxPyBeginAllowThreads();
16676 (arg1)->ComputeScaleAndOrigin();
16677
16678 wxPyEndAllowThreads(__tstate);
16679 if (PyErr_Occurred()) SWIG_fail;
16680 }
16681 Py_INCREF(Py_None); resultobj = Py_None;
16682 return resultobj;
16683 fail:
16684 return NULL;
16685 }
16686
16687
16688 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16689 PyObject *resultobj;
16690 wxDC *arg1 = (wxDC *) 0 ;
16691 int arg2 ;
16692 int arg3 ;
16693 PyObject * obj0 = 0 ;
16694 PyObject * obj1 = 0 ;
16695 PyObject * obj2 = 0 ;
16696 char *kwnames[] = {
16697 (char *) "self",(char *) "x",(char *) "y", NULL
16698 };
16699
16700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
16701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16702 if (SWIG_arg_fail(1)) SWIG_fail;
16703 {
16704 arg2 = (int)(SWIG_As_int(obj1));
16705 if (SWIG_arg_fail(2)) SWIG_fail;
16706 }
16707 {
16708 arg3 = (int)(SWIG_As_int(obj2));
16709 if (SWIG_arg_fail(3)) SWIG_fail;
16710 }
16711 {
16712 PyThreadState* __tstate = wxPyBeginAllowThreads();
16713 (arg1)->CalcBoundingBox(arg2,arg3);
16714
16715 wxPyEndAllowThreads(__tstate);
16716 if (PyErr_Occurred()) SWIG_fail;
16717 }
16718 Py_INCREF(Py_None); resultobj = Py_None;
16719 return resultobj;
16720 fail:
16721 return NULL;
16722 }
16723
16724
16725 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16726 PyObject *resultobj;
16727 wxDC *arg1 = (wxDC *) 0 ;
16728 wxPoint *arg2 = 0 ;
16729 wxPoint temp2 ;
16730 PyObject * obj0 = 0 ;
16731 PyObject * obj1 = 0 ;
16732 char *kwnames[] = {
16733 (char *) "self",(char *) "point", NULL
16734 };
16735
16736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
16737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16738 if (SWIG_arg_fail(1)) SWIG_fail;
16739 {
16740 arg2 = &temp2;
16741 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16742 }
16743 {
16744 PyThreadState* __tstate = wxPyBeginAllowThreads();
16745 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
16746
16747 wxPyEndAllowThreads(__tstate);
16748 if (PyErr_Occurred()) SWIG_fail;
16749 }
16750 Py_INCREF(Py_None); resultobj = Py_None;
16751 return resultobj;
16752 fail:
16753 return NULL;
16754 }
16755
16756
16757 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16758 PyObject *resultobj;
16759 wxDC *arg1 = (wxDC *) 0 ;
16760 PyObject * obj0 = 0 ;
16761 char *kwnames[] = {
16762 (char *) "self", NULL
16763 };
16764
16765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
16766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16767 if (SWIG_arg_fail(1)) SWIG_fail;
16768 {
16769 PyThreadState* __tstate = wxPyBeginAllowThreads();
16770 (arg1)->ResetBoundingBox();
16771
16772 wxPyEndAllowThreads(__tstate);
16773 if (PyErr_Occurred()) SWIG_fail;
16774 }
16775 Py_INCREF(Py_None); resultobj = Py_None;
16776 return resultobj;
16777 fail:
16778 return NULL;
16779 }
16780
16781
16782 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
16783 PyObject *resultobj;
16784 wxDC *arg1 = (wxDC *) 0 ;
16785 int result;
16786 PyObject * obj0 = 0 ;
16787 char *kwnames[] = {
16788 (char *) "self", NULL
16789 };
16790
16791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
16792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16793 if (SWIG_arg_fail(1)) SWIG_fail;
16794 {
16795 PyThreadState* __tstate = wxPyBeginAllowThreads();
16796 result = (int)((wxDC const *)arg1)->MinX();
16797
16798 wxPyEndAllowThreads(__tstate);
16799 if (PyErr_Occurred()) SWIG_fail;
16800 }
16801 {
16802 resultobj = SWIG_From_int((int)(result));
16803 }
16804 return resultobj;
16805 fail:
16806 return NULL;
16807 }
16808
16809
16810 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
16811 PyObject *resultobj;
16812 wxDC *arg1 = (wxDC *) 0 ;
16813 int result;
16814 PyObject * obj0 = 0 ;
16815 char *kwnames[] = {
16816 (char *) "self", NULL
16817 };
16818
16819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
16820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16821 if (SWIG_arg_fail(1)) SWIG_fail;
16822 {
16823 PyThreadState* __tstate = wxPyBeginAllowThreads();
16824 result = (int)((wxDC const *)arg1)->MaxX();
16825
16826 wxPyEndAllowThreads(__tstate);
16827 if (PyErr_Occurred()) SWIG_fail;
16828 }
16829 {
16830 resultobj = SWIG_From_int((int)(result));
16831 }
16832 return resultobj;
16833 fail:
16834 return NULL;
16835 }
16836
16837
16838 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
16839 PyObject *resultobj;
16840 wxDC *arg1 = (wxDC *) 0 ;
16841 int result;
16842 PyObject * obj0 = 0 ;
16843 char *kwnames[] = {
16844 (char *) "self", NULL
16845 };
16846
16847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
16848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16849 if (SWIG_arg_fail(1)) SWIG_fail;
16850 {
16851 PyThreadState* __tstate = wxPyBeginAllowThreads();
16852 result = (int)((wxDC const *)arg1)->MinY();
16853
16854 wxPyEndAllowThreads(__tstate);
16855 if (PyErr_Occurred()) SWIG_fail;
16856 }
16857 {
16858 resultobj = SWIG_From_int((int)(result));
16859 }
16860 return resultobj;
16861 fail:
16862 return NULL;
16863 }
16864
16865
16866 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
16867 PyObject *resultobj;
16868 wxDC *arg1 = (wxDC *) 0 ;
16869 int result;
16870 PyObject * obj0 = 0 ;
16871 char *kwnames[] = {
16872 (char *) "self", NULL
16873 };
16874
16875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
16876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16877 if (SWIG_arg_fail(1)) SWIG_fail;
16878 {
16879 PyThreadState* __tstate = wxPyBeginAllowThreads();
16880 result = (int)((wxDC const *)arg1)->MaxY();
16881
16882 wxPyEndAllowThreads(__tstate);
16883 if (PyErr_Occurred()) SWIG_fail;
16884 }
16885 {
16886 resultobj = SWIG_From_int((int)(result));
16887 }
16888 return resultobj;
16889 fail:
16890 return NULL;
16891 }
16892
16893
16894 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16895 PyObject *resultobj;
16896 wxDC *arg1 = (wxDC *) 0 ;
16897 int *arg2 = (int *) 0 ;
16898 int *arg3 = (int *) 0 ;
16899 int *arg4 = (int *) 0 ;
16900 int *arg5 = (int *) 0 ;
16901 int temp2 ;
16902 int res2 = 0 ;
16903 int temp3 ;
16904 int res3 = 0 ;
16905 int temp4 ;
16906 int res4 = 0 ;
16907 int temp5 ;
16908 int res5 = 0 ;
16909 PyObject * obj0 = 0 ;
16910 char *kwnames[] = {
16911 (char *) "self", NULL
16912 };
16913
16914 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16915 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16916 arg4 = &temp4; res4 = SWIG_NEWOBJ;
16917 arg5 = &temp5; res5 = SWIG_NEWOBJ;
16918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
16919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16920 if (SWIG_arg_fail(1)) SWIG_fail;
16921 {
16922 PyThreadState* __tstate = wxPyBeginAllowThreads();
16923 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
16924
16925 wxPyEndAllowThreads(__tstate);
16926 if (PyErr_Occurred()) SWIG_fail;
16927 }
16928 Py_INCREF(Py_None); resultobj = Py_None;
16929 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16930 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16931 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16932 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16933 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
16934 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
16935 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
16936 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
16937 return resultobj;
16938 fail:
16939 return NULL;
16940 }
16941
16942
16943 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
16944 PyObject *resultobj;
16945 wxDC *arg1 = (wxDC *) 0 ;
16946 PyObject *arg2 = (PyObject *) 0 ;
16947 PyObject *arg3 = (PyObject *) 0 ;
16948 PyObject *arg4 = (PyObject *) 0 ;
16949 PyObject *result;
16950 PyObject * obj0 = 0 ;
16951 PyObject * obj1 = 0 ;
16952 PyObject * obj2 = 0 ;
16953 PyObject * obj3 = 0 ;
16954 char *kwnames[] = {
16955 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16956 };
16957
16958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16960 if (SWIG_arg_fail(1)) SWIG_fail;
16961 arg2 = obj1;
16962 arg3 = obj2;
16963 arg4 = obj3;
16964 {
16965 PyThreadState* __tstate = wxPyBeginAllowThreads();
16966 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
16967
16968 wxPyEndAllowThreads(__tstate);
16969 if (PyErr_Occurred()) SWIG_fail;
16970 }
16971 resultobj = result;
16972 return resultobj;
16973 fail:
16974 return NULL;
16975 }
16976
16977
16978 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
16979 PyObject *resultobj;
16980 wxDC *arg1 = (wxDC *) 0 ;
16981 PyObject *arg2 = (PyObject *) 0 ;
16982 PyObject *arg3 = (PyObject *) 0 ;
16983 PyObject *arg4 = (PyObject *) 0 ;
16984 PyObject *result;
16985 PyObject * obj0 = 0 ;
16986 PyObject * obj1 = 0 ;
16987 PyObject * obj2 = 0 ;
16988 PyObject * obj3 = 0 ;
16989 char *kwnames[] = {
16990 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16991 };
16992
16993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg2 = obj1;
16997 arg3 = obj2;
16998 arg4 = obj3;
16999 {
17000 PyThreadState* __tstate = wxPyBeginAllowThreads();
17001 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
17002
17003 wxPyEndAllowThreads(__tstate);
17004 if (PyErr_Occurred()) SWIG_fail;
17005 }
17006 resultobj = result;
17007 return resultobj;
17008 fail:
17009 return NULL;
17010 }
17011
17012
17013 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
17014 PyObject *resultobj;
17015 wxDC *arg1 = (wxDC *) 0 ;
17016 PyObject *arg2 = (PyObject *) 0 ;
17017 PyObject *arg3 = (PyObject *) 0 ;
17018 PyObject *arg4 = (PyObject *) 0 ;
17019 PyObject *result;
17020 PyObject * obj0 = 0 ;
17021 PyObject * obj1 = 0 ;
17022 PyObject * obj2 = 0 ;
17023 PyObject * obj3 = 0 ;
17024 char *kwnames[] = {
17025 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17026 };
17027
17028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17030 if (SWIG_arg_fail(1)) SWIG_fail;
17031 arg2 = obj1;
17032 arg3 = obj2;
17033 arg4 = obj3;
17034 {
17035 PyThreadState* __tstate = wxPyBeginAllowThreads();
17036 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17037
17038 wxPyEndAllowThreads(__tstate);
17039 if (PyErr_Occurred()) SWIG_fail;
17040 }
17041 resultobj = result;
17042 return resultobj;
17043 fail:
17044 return NULL;
17045 }
17046
17047
17048 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17049 PyObject *resultobj;
17050 wxDC *arg1 = (wxDC *) 0 ;
17051 PyObject *arg2 = (PyObject *) 0 ;
17052 PyObject *arg3 = (PyObject *) 0 ;
17053 PyObject *arg4 = (PyObject *) 0 ;
17054 PyObject *result;
17055 PyObject * obj0 = 0 ;
17056 PyObject * obj1 = 0 ;
17057 PyObject * obj2 = 0 ;
17058 PyObject * obj3 = 0 ;
17059 char *kwnames[] = {
17060 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17061 };
17062
17063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17065 if (SWIG_arg_fail(1)) SWIG_fail;
17066 arg2 = obj1;
17067 arg3 = obj2;
17068 arg4 = obj3;
17069 {
17070 PyThreadState* __tstate = wxPyBeginAllowThreads();
17071 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17072
17073 wxPyEndAllowThreads(__tstate);
17074 if (PyErr_Occurred()) SWIG_fail;
17075 }
17076 resultobj = result;
17077 return resultobj;
17078 fail:
17079 return NULL;
17080 }
17081
17082
17083 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17084 PyObject *resultobj;
17085 wxDC *arg1 = (wxDC *) 0 ;
17086 PyObject *arg2 = (PyObject *) 0 ;
17087 PyObject *arg3 = (PyObject *) 0 ;
17088 PyObject *arg4 = (PyObject *) 0 ;
17089 PyObject *result;
17090 PyObject * obj0 = 0 ;
17091 PyObject * obj1 = 0 ;
17092 PyObject * obj2 = 0 ;
17093 PyObject * obj3 = 0 ;
17094 char *kwnames[] = {
17095 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17096 };
17097
17098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17100 if (SWIG_arg_fail(1)) SWIG_fail;
17101 arg2 = obj1;
17102 arg3 = obj2;
17103 arg4 = obj3;
17104 {
17105 PyThreadState* __tstate = wxPyBeginAllowThreads();
17106 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17107
17108 wxPyEndAllowThreads(__tstate);
17109 if (PyErr_Occurred()) SWIG_fail;
17110 }
17111 resultobj = result;
17112 return resultobj;
17113 fail:
17114 return NULL;
17115 }
17116
17117
17118 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17119 PyObject *resultobj;
17120 wxDC *arg1 = (wxDC *) 0 ;
17121 PyObject *arg2 = (PyObject *) 0 ;
17122 PyObject *arg3 = (PyObject *) 0 ;
17123 PyObject *arg4 = (PyObject *) 0 ;
17124 PyObject *arg5 = (PyObject *) 0 ;
17125 PyObject *result;
17126 PyObject * obj0 = 0 ;
17127 PyObject * obj1 = 0 ;
17128 PyObject * obj2 = 0 ;
17129 PyObject * obj3 = 0 ;
17130 PyObject * obj4 = 0 ;
17131 char *kwnames[] = {
17132 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17133 };
17134
17135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17137 if (SWIG_arg_fail(1)) SWIG_fail;
17138 arg2 = obj1;
17139 arg3 = obj2;
17140 arg4 = obj3;
17141 arg5 = obj4;
17142 {
17143 PyThreadState* __tstate = wxPyBeginAllowThreads();
17144 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17145
17146 wxPyEndAllowThreads(__tstate);
17147 if (PyErr_Occurred()) SWIG_fail;
17148 }
17149 resultobj = result;
17150 return resultobj;
17151 fail:
17152 return NULL;
17153 }
17154
17155
17156 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17157 PyObject *obj;
17158 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17159 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17160 Py_INCREF(obj);
17161 return Py_BuildValue((char *)"");
17162 }
17163 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17164 PyObject *resultobj;
17165 wxMemoryDC *result;
17166 char *kwnames[] = {
17167 NULL
17168 };
17169
17170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17171 {
17172 if (!wxPyCheckForApp()) SWIG_fail;
17173 PyThreadState* __tstate = wxPyBeginAllowThreads();
17174 result = (wxMemoryDC *)new wxMemoryDC();
17175
17176 wxPyEndAllowThreads(__tstate);
17177 if (PyErr_Occurred()) SWIG_fail;
17178 }
17179 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17180 return resultobj;
17181 fail:
17182 return NULL;
17183 }
17184
17185
17186 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17187 PyObject *resultobj;
17188 wxDC *arg1 = (wxDC *) 0 ;
17189 wxMemoryDC *result;
17190 PyObject * obj0 = 0 ;
17191 char *kwnames[] = {
17192 (char *) "oldDC", NULL
17193 };
17194
17195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17197 if (SWIG_arg_fail(1)) SWIG_fail;
17198 {
17199 if (!wxPyCheckForApp()) SWIG_fail;
17200 PyThreadState* __tstate = wxPyBeginAllowThreads();
17201 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17202
17203 wxPyEndAllowThreads(__tstate);
17204 if (PyErr_Occurred()) SWIG_fail;
17205 }
17206 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17207 return resultobj;
17208 fail:
17209 return NULL;
17210 }
17211
17212
17213 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17214 PyObject *resultobj;
17215 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17216 wxBitmap *arg2 = 0 ;
17217 PyObject * obj0 = 0 ;
17218 PyObject * obj1 = 0 ;
17219 char *kwnames[] = {
17220 (char *) "self",(char *) "bitmap", NULL
17221 };
17222
17223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17225 if (SWIG_arg_fail(1)) SWIG_fail;
17226 {
17227 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17228 if (SWIG_arg_fail(2)) SWIG_fail;
17229 if (arg2 == NULL) {
17230 SWIG_null_ref("wxBitmap");
17231 }
17232 if (SWIG_arg_fail(2)) SWIG_fail;
17233 }
17234 {
17235 PyThreadState* __tstate = wxPyBeginAllowThreads();
17236 (arg1)->SelectObject((wxBitmap const &)*arg2);
17237
17238 wxPyEndAllowThreads(__tstate);
17239 if (PyErr_Occurred()) SWIG_fail;
17240 }
17241 Py_INCREF(Py_None); resultobj = Py_None;
17242 return resultobj;
17243 fail:
17244 return NULL;
17245 }
17246
17247
17248 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17249 PyObject *obj;
17250 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17251 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17252 Py_INCREF(obj);
17253 return Py_BuildValue((char *)"");
17254 }
17255 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17256 PyObject *resultobj;
17257 wxDC *arg1 = (wxDC *) 0 ;
17258 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17259 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17260 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17261 wxBufferedDC *result;
17262 PyObject * obj0 = 0 ;
17263 PyObject * obj1 = 0 ;
17264 PyObject * obj2 = 0 ;
17265
17266 if(!PyArg_ParseTuple(args,(char *)"O|OO:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17268 if (SWIG_arg_fail(1)) SWIG_fail;
17269 if (obj1) {
17270 {
17271 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17272 if (SWIG_arg_fail(2)) SWIG_fail;
17273 if (arg2 == NULL) {
17274 SWIG_null_ref("wxBitmap");
17275 }
17276 if (SWIG_arg_fail(2)) SWIG_fail;
17277 }
17278 }
17279 if (obj2) {
17280 {
17281 arg3 = (int)(SWIG_As_int(obj2));
17282 if (SWIG_arg_fail(3)) SWIG_fail;
17283 }
17284 }
17285 {
17286 if (!wxPyCheckForApp()) SWIG_fail;
17287 PyThreadState* __tstate = wxPyBeginAllowThreads();
17288 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
17289
17290 wxPyEndAllowThreads(__tstate);
17291 if (PyErr_Occurred()) SWIG_fail;
17292 }
17293 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17294 return resultobj;
17295 fail:
17296 return NULL;
17297 }
17298
17299
17300 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17301 PyObject *resultobj;
17302 wxDC *arg1 = (wxDC *) 0 ;
17303 wxSize *arg2 = 0 ;
17304 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17305 wxBufferedDC *result;
17306 wxSize temp2 ;
17307 PyObject * obj0 = 0 ;
17308 PyObject * obj1 = 0 ;
17309 PyObject * obj2 = 0 ;
17310
17311 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17313 if (SWIG_arg_fail(1)) SWIG_fail;
17314 {
17315 arg2 = &temp2;
17316 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17317 }
17318 if (obj2) {
17319 {
17320 arg3 = (int)(SWIG_As_int(obj2));
17321 if (SWIG_arg_fail(3)) SWIG_fail;
17322 }
17323 }
17324 {
17325 if (!wxPyCheckForApp()) SWIG_fail;
17326 PyThreadState* __tstate = wxPyBeginAllowThreads();
17327 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
17328
17329 wxPyEndAllowThreads(__tstate);
17330 if (PyErr_Occurred()) SWIG_fail;
17331 }
17332 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17333 return resultobj;
17334 fail:
17335 return NULL;
17336 }
17337
17338
17339 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
17340 int argc;
17341 PyObject *argv[4];
17342 int ii;
17343
17344 argc = PyObject_Length(args);
17345 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
17346 argv[ii] = PyTuple_GetItem(args,ii);
17347 }
17348 if ((argc >= 1) && (argc <= 3)) {
17349 int _v;
17350 {
17351 void *ptr;
17352 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17353 _v = 0;
17354 PyErr_Clear();
17355 } else {
17356 _v = 1;
17357 }
17358 }
17359 if (_v) {
17360 if (argc <= 1) {
17361 return _wrap_new_BufferedDC__SWIG_0(self,args);
17362 }
17363 {
17364 void *ptr = 0;
17365 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
17366 _v = 0;
17367 PyErr_Clear();
17368 } else {
17369 _v = (ptr != 0);
17370 }
17371 }
17372 if (_v) {
17373 if (argc <= 2) {
17374 return _wrap_new_BufferedDC__SWIG_0(self,args);
17375 }
17376 _v = SWIG_Check_int(argv[2]);
17377 if (_v) {
17378 return _wrap_new_BufferedDC__SWIG_0(self,args);
17379 }
17380 }
17381 }
17382 }
17383 if ((argc >= 2) && (argc <= 3)) {
17384 int _v;
17385 {
17386 void *ptr;
17387 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17388 _v = 0;
17389 PyErr_Clear();
17390 } else {
17391 _v = 1;
17392 }
17393 }
17394 if (_v) {
17395 {
17396 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
17397 }
17398 if (_v) {
17399 if (argc <= 2) {
17400 return _wrap_new_BufferedDC__SWIG_1(self,args);
17401 }
17402 _v = SWIG_Check_int(argv[2]);
17403 if (_v) {
17404 return _wrap_new_BufferedDC__SWIG_1(self,args);
17405 }
17406 }
17407 }
17408 }
17409
17410 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
17411 return NULL;
17412 }
17413
17414
17415 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
17416 PyObject *resultobj;
17417 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17418 PyObject * obj0 = 0 ;
17419 char *kwnames[] = {
17420 (char *) "self", NULL
17421 };
17422
17423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
17424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17425 if (SWIG_arg_fail(1)) SWIG_fail;
17426 {
17427 PyThreadState* __tstate = wxPyBeginAllowThreads();
17428 delete arg1;
17429
17430 wxPyEndAllowThreads(__tstate);
17431 if (PyErr_Occurred()) SWIG_fail;
17432 }
17433 Py_INCREF(Py_None); resultobj = Py_None;
17434 return resultobj;
17435 fail:
17436 return NULL;
17437 }
17438
17439
17440 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
17441 PyObject *resultobj;
17442 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17443 PyObject * obj0 = 0 ;
17444 char *kwnames[] = {
17445 (char *) "self", NULL
17446 };
17447
17448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
17449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17450 if (SWIG_arg_fail(1)) SWIG_fail;
17451 {
17452 PyThreadState* __tstate = wxPyBeginAllowThreads();
17453 (arg1)->UnMask();
17454
17455 wxPyEndAllowThreads(__tstate);
17456 if (PyErr_Occurred()) SWIG_fail;
17457 }
17458 Py_INCREF(Py_None); resultobj = Py_None;
17459 return resultobj;
17460 fail:
17461 return NULL;
17462 }
17463
17464
17465 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
17466 PyObject *obj;
17467 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17468 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
17469 Py_INCREF(obj);
17470 return Py_BuildValue((char *)"");
17471 }
17472 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17473 PyObject *resultobj;
17474 wxWindow *arg1 = (wxWindow *) 0 ;
17475 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17476 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17477 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17478 wxBufferedPaintDC *result;
17479 PyObject * obj0 = 0 ;
17480 PyObject * obj1 = 0 ;
17481 PyObject * obj2 = 0 ;
17482 char *kwnames[] = {
17483 (char *) "window",(char *) "buffer",(char *) "style", NULL
17484 };
17485
17486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
17487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17488 if (SWIG_arg_fail(1)) SWIG_fail;
17489 if (obj1) {
17490 {
17491 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17492 if (SWIG_arg_fail(2)) SWIG_fail;
17493 if (arg2 == NULL) {
17494 SWIG_null_ref("wxBitmap");
17495 }
17496 if (SWIG_arg_fail(2)) SWIG_fail;
17497 }
17498 }
17499 if (obj2) {
17500 {
17501 arg3 = (int)(SWIG_As_int(obj2));
17502 if (SWIG_arg_fail(3)) SWIG_fail;
17503 }
17504 }
17505 {
17506 if (!wxPyCheckForApp()) SWIG_fail;
17507 PyThreadState* __tstate = wxPyBeginAllowThreads();
17508 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
17509
17510 wxPyEndAllowThreads(__tstate);
17511 if (PyErr_Occurred()) SWIG_fail;
17512 }
17513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
17514 return resultobj;
17515 fail:
17516 return NULL;
17517 }
17518
17519
17520 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
17521 PyObject *obj;
17522 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17523 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
17524 Py_INCREF(obj);
17525 return Py_BuildValue((char *)"");
17526 }
17527 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
17528 PyObject *resultobj;
17529 wxScreenDC *result;
17530 char *kwnames[] = {
17531 NULL
17532 };
17533
17534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
17535 {
17536 if (!wxPyCheckForApp()) SWIG_fail;
17537 PyThreadState* __tstate = wxPyBeginAllowThreads();
17538 result = (wxScreenDC *)new wxScreenDC();
17539
17540 wxPyEndAllowThreads(__tstate);
17541 if (PyErr_Occurred()) SWIG_fail;
17542 }
17543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
17544 return resultobj;
17545 fail:
17546 return NULL;
17547 }
17548
17549
17550 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
17551 PyObject *resultobj;
17552 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17553 wxWindow *arg2 = (wxWindow *) 0 ;
17554 bool result;
17555 PyObject * obj0 = 0 ;
17556 PyObject * obj1 = 0 ;
17557 char *kwnames[] = {
17558 (char *) "self",(char *) "window", NULL
17559 };
17560
17561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
17562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17563 if (SWIG_arg_fail(1)) SWIG_fail;
17564 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17565 if (SWIG_arg_fail(2)) SWIG_fail;
17566 {
17567 PyThreadState* __tstate = wxPyBeginAllowThreads();
17568 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17569
17570 wxPyEndAllowThreads(__tstate);
17571 if (PyErr_Occurred()) SWIG_fail;
17572 }
17573 {
17574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17575 }
17576 return resultobj;
17577 fail:
17578 return NULL;
17579 }
17580
17581
17582 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17583 PyObject *resultobj;
17584 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17585 wxRect *arg2 = (wxRect *) NULL ;
17586 bool result;
17587 PyObject * obj0 = 0 ;
17588 PyObject * obj1 = 0 ;
17589 char *kwnames[] = {
17590 (char *) "self",(char *) "rect", NULL
17591 };
17592
17593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
17594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17595 if (SWIG_arg_fail(1)) SWIG_fail;
17596 if (obj1) {
17597 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
17598 if (SWIG_arg_fail(2)) SWIG_fail;
17599 }
17600 {
17601 PyThreadState* __tstate = wxPyBeginAllowThreads();
17602 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17603
17604 wxPyEndAllowThreads(__tstate);
17605 if (PyErr_Occurred()) SWIG_fail;
17606 }
17607 {
17608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17609 }
17610 return resultobj;
17611 fail:
17612 return NULL;
17613 }
17614
17615
17616 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17617 PyObject *resultobj;
17618 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17619 bool result;
17620 PyObject * obj0 = 0 ;
17621 char *kwnames[] = {
17622 (char *) "self", NULL
17623 };
17624
17625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
17626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17627 if (SWIG_arg_fail(1)) SWIG_fail;
17628 {
17629 PyThreadState* __tstate = wxPyBeginAllowThreads();
17630 result = (bool)(arg1)->EndDrawingOnTop();
17631
17632 wxPyEndAllowThreads(__tstate);
17633 if (PyErr_Occurred()) SWIG_fail;
17634 }
17635 {
17636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17637 }
17638 return resultobj;
17639 fail:
17640 return NULL;
17641 }
17642
17643
17644 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
17645 PyObject *obj;
17646 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17647 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
17648 Py_INCREF(obj);
17649 return Py_BuildValue((char *)"");
17650 }
17651 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
17652 PyObject *resultobj;
17653 wxWindow *arg1 = (wxWindow *) 0 ;
17654 wxClientDC *result;
17655 PyObject * obj0 = 0 ;
17656 char *kwnames[] = {
17657 (char *) "win", NULL
17658 };
17659
17660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
17661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17662 if (SWIG_arg_fail(1)) SWIG_fail;
17663 {
17664 if (!wxPyCheckForApp()) SWIG_fail;
17665 PyThreadState* __tstate = wxPyBeginAllowThreads();
17666 result = (wxClientDC *)new wxClientDC(arg1);
17667
17668 wxPyEndAllowThreads(__tstate);
17669 if (PyErr_Occurred()) SWIG_fail;
17670 }
17671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
17672 return resultobj;
17673 fail:
17674 return NULL;
17675 }
17676
17677
17678 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
17679 PyObject *obj;
17680 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17681 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
17682 Py_INCREF(obj);
17683 return Py_BuildValue((char *)"");
17684 }
17685 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17686 PyObject *resultobj;
17687 wxWindow *arg1 = (wxWindow *) 0 ;
17688 wxPaintDC *result;
17689 PyObject * obj0 = 0 ;
17690 char *kwnames[] = {
17691 (char *) "win", NULL
17692 };
17693
17694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
17695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17696 if (SWIG_arg_fail(1)) SWIG_fail;
17697 {
17698 if (!wxPyCheckForApp()) SWIG_fail;
17699 PyThreadState* __tstate = wxPyBeginAllowThreads();
17700 result = (wxPaintDC *)new wxPaintDC(arg1);
17701
17702 wxPyEndAllowThreads(__tstate);
17703 if (PyErr_Occurred()) SWIG_fail;
17704 }
17705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
17706 return resultobj;
17707 fail:
17708 return NULL;
17709 }
17710
17711
17712 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
17713 PyObject *obj;
17714 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17715 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
17716 Py_INCREF(obj);
17717 return Py_BuildValue((char *)"");
17718 }
17719 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
17720 PyObject *resultobj;
17721 wxWindow *arg1 = (wxWindow *) 0 ;
17722 wxWindowDC *result;
17723 PyObject * obj0 = 0 ;
17724 char *kwnames[] = {
17725 (char *) "win", NULL
17726 };
17727
17728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
17729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17730 if (SWIG_arg_fail(1)) SWIG_fail;
17731 {
17732 if (!wxPyCheckForApp()) SWIG_fail;
17733 PyThreadState* __tstate = wxPyBeginAllowThreads();
17734 result = (wxWindowDC *)new wxWindowDC(arg1);
17735
17736 wxPyEndAllowThreads(__tstate);
17737 if (PyErr_Occurred()) SWIG_fail;
17738 }
17739 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
17740 return resultobj;
17741 fail:
17742 return NULL;
17743 }
17744
17745
17746 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
17747 PyObject *obj;
17748 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17749 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
17750 Py_INCREF(obj);
17751 return Py_BuildValue((char *)"");
17752 }
17753 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
17754 PyObject *resultobj;
17755 wxDC *arg1 = 0 ;
17756 bool arg2 ;
17757 wxMirrorDC *result;
17758 PyObject * obj0 = 0 ;
17759 PyObject * obj1 = 0 ;
17760 char *kwnames[] = {
17761 (char *) "dc",(char *) "mirror", NULL
17762 };
17763
17764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
17765 {
17766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17767 if (SWIG_arg_fail(1)) SWIG_fail;
17768 if (arg1 == NULL) {
17769 SWIG_null_ref("wxDC");
17770 }
17771 if (SWIG_arg_fail(1)) SWIG_fail;
17772 }
17773 {
17774 arg2 = (bool)(SWIG_As_bool(obj1));
17775 if (SWIG_arg_fail(2)) SWIG_fail;
17776 }
17777 {
17778 if (!wxPyCheckForApp()) SWIG_fail;
17779 PyThreadState* __tstate = wxPyBeginAllowThreads();
17780 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
17781
17782 wxPyEndAllowThreads(__tstate);
17783 if (PyErr_Occurred()) SWIG_fail;
17784 }
17785 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
17786 return resultobj;
17787 fail:
17788 return NULL;
17789 }
17790
17791
17792 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
17793 PyObject *obj;
17794 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17795 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
17796 Py_INCREF(obj);
17797 return Py_BuildValue((char *)"");
17798 }
17799 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
17800 PyObject *resultobj;
17801 wxPrintData *arg1 = 0 ;
17802 wxPostScriptDC *result;
17803 PyObject * obj0 = 0 ;
17804 char *kwnames[] = {
17805 (char *) "printData", NULL
17806 };
17807
17808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
17809 {
17810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17811 if (SWIG_arg_fail(1)) SWIG_fail;
17812 if (arg1 == NULL) {
17813 SWIG_null_ref("wxPrintData");
17814 }
17815 if (SWIG_arg_fail(1)) SWIG_fail;
17816 }
17817 {
17818 if (!wxPyCheckForApp()) SWIG_fail;
17819 PyThreadState* __tstate = wxPyBeginAllowThreads();
17820 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
17821
17822 wxPyEndAllowThreads(__tstate);
17823 if (PyErr_Occurred()) SWIG_fail;
17824 }
17825 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
17826 return resultobj;
17827 fail:
17828 return NULL;
17829 }
17830
17831
17832 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17833 PyObject *resultobj;
17834 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17835 wxPrintData *result;
17836 PyObject * obj0 = 0 ;
17837 char *kwnames[] = {
17838 (char *) "self", NULL
17839 };
17840
17841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
17842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17843 if (SWIG_arg_fail(1)) SWIG_fail;
17844 {
17845 PyThreadState* __tstate = wxPyBeginAllowThreads();
17846 {
17847 wxPrintData &_result_ref = (arg1)->GetPrintData();
17848 result = (wxPrintData *) &_result_ref;
17849 }
17850
17851 wxPyEndAllowThreads(__tstate);
17852 if (PyErr_Occurred()) SWIG_fail;
17853 }
17854 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
17855 return resultobj;
17856 fail:
17857 return NULL;
17858 }
17859
17860
17861 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17862 PyObject *resultobj;
17863 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17864 wxPrintData *arg2 = 0 ;
17865 PyObject * obj0 = 0 ;
17866 PyObject * obj1 = 0 ;
17867 char *kwnames[] = {
17868 (char *) "self",(char *) "data", NULL
17869 };
17870
17871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
17872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17873 if (SWIG_arg_fail(1)) SWIG_fail;
17874 {
17875 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17876 if (SWIG_arg_fail(2)) SWIG_fail;
17877 if (arg2 == NULL) {
17878 SWIG_null_ref("wxPrintData");
17879 }
17880 if (SWIG_arg_fail(2)) SWIG_fail;
17881 }
17882 {
17883 PyThreadState* __tstate = wxPyBeginAllowThreads();
17884 (arg1)->SetPrintData((wxPrintData const &)*arg2);
17885
17886 wxPyEndAllowThreads(__tstate);
17887 if (PyErr_Occurred()) SWIG_fail;
17888 }
17889 Py_INCREF(Py_None); resultobj = Py_None;
17890 return resultobj;
17891 fail:
17892 return NULL;
17893 }
17894
17895
17896 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17897 PyObject *resultobj;
17898 int arg1 ;
17899 PyObject * obj0 = 0 ;
17900 char *kwnames[] = {
17901 (char *) "ppi", NULL
17902 };
17903
17904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
17905 {
17906 arg1 = (int)(SWIG_As_int(obj0));
17907 if (SWIG_arg_fail(1)) SWIG_fail;
17908 }
17909 {
17910 PyThreadState* __tstate = wxPyBeginAllowThreads();
17911 wxPostScriptDC::SetResolution(arg1);
17912
17913 wxPyEndAllowThreads(__tstate);
17914 if (PyErr_Occurred()) SWIG_fail;
17915 }
17916 Py_INCREF(Py_None); resultobj = Py_None;
17917 return resultobj;
17918 fail:
17919 return NULL;
17920 }
17921
17922
17923 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17924 PyObject *resultobj;
17925 int result;
17926 char *kwnames[] = {
17927 NULL
17928 };
17929
17930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
17931 {
17932 PyThreadState* __tstate = wxPyBeginAllowThreads();
17933 result = (int)wxPostScriptDC::GetResolution();
17934
17935 wxPyEndAllowThreads(__tstate);
17936 if (PyErr_Occurred()) SWIG_fail;
17937 }
17938 {
17939 resultobj = SWIG_From_int((int)(result));
17940 }
17941 return resultobj;
17942 fail:
17943 return NULL;
17944 }
17945
17946
17947 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
17948 PyObject *obj;
17949 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17950 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
17951 Py_INCREF(obj);
17952 return Py_BuildValue((char *)"");
17953 }
17954 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
17955 PyObject *resultobj;
17956 wxString const &arg1_defvalue = wxPyEmptyString ;
17957 wxString *arg1 = (wxString *) &arg1_defvalue ;
17958 wxMetaFile *result;
17959 bool temp1 = false ;
17960 PyObject * obj0 = 0 ;
17961 char *kwnames[] = {
17962 (char *) "filename", NULL
17963 };
17964
17965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
17966 if (obj0) {
17967 {
17968 arg1 = wxString_in_helper(obj0);
17969 if (arg1 == NULL) SWIG_fail;
17970 temp1 = true;
17971 }
17972 }
17973 {
17974 if (!wxPyCheckForApp()) SWIG_fail;
17975 PyThreadState* __tstate = wxPyBeginAllowThreads();
17976 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
17977
17978 wxPyEndAllowThreads(__tstate);
17979 if (PyErr_Occurred()) SWIG_fail;
17980 }
17981 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
17982 {
17983 if (temp1)
17984 delete arg1;
17985 }
17986 return resultobj;
17987 fail:
17988 {
17989 if (temp1)
17990 delete arg1;
17991 }
17992 return NULL;
17993 }
17994
17995
17996 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
17997 PyObject *obj;
17998 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17999 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
18000 Py_INCREF(obj);
18001 return Py_BuildValue((char *)"");
18002 }
18003 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
18004 PyObject *resultobj;
18005 wxString const &arg1_defvalue = wxPyEmptyString ;
18006 wxString *arg1 = (wxString *) &arg1_defvalue ;
18007 int arg2 = (int) 0 ;
18008 int arg3 = (int) 0 ;
18009 wxString const &arg4_defvalue = wxPyEmptyString ;
18010 wxString *arg4 = (wxString *) &arg4_defvalue ;
18011 wxMetaFileDC *result;
18012 bool temp1 = false ;
18013 bool temp4 = false ;
18014 PyObject * obj0 = 0 ;
18015 PyObject * obj1 = 0 ;
18016 PyObject * obj2 = 0 ;
18017 PyObject * obj3 = 0 ;
18018 char *kwnames[] = {
18019 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
18020 };
18021
18022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18023 if (obj0) {
18024 {
18025 arg1 = wxString_in_helper(obj0);
18026 if (arg1 == NULL) SWIG_fail;
18027 temp1 = true;
18028 }
18029 }
18030 if (obj1) {
18031 {
18032 arg2 = (int)(SWIG_As_int(obj1));
18033 if (SWIG_arg_fail(2)) SWIG_fail;
18034 }
18035 }
18036 if (obj2) {
18037 {
18038 arg3 = (int)(SWIG_As_int(obj2));
18039 if (SWIG_arg_fail(3)) SWIG_fail;
18040 }
18041 }
18042 if (obj3) {
18043 {
18044 arg4 = wxString_in_helper(obj3);
18045 if (arg4 == NULL) SWIG_fail;
18046 temp4 = true;
18047 }
18048 }
18049 {
18050 if (!wxPyCheckForApp()) SWIG_fail;
18051 PyThreadState* __tstate = wxPyBeginAllowThreads();
18052 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
18053
18054 wxPyEndAllowThreads(__tstate);
18055 if (PyErr_Occurred()) SWIG_fail;
18056 }
18057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
18058 {
18059 if (temp1)
18060 delete arg1;
18061 }
18062 {
18063 if (temp4)
18064 delete arg4;
18065 }
18066 return resultobj;
18067 fail:
18068 {
18069 if (temp1)
18070 delete arg1;
18071 }
18072 {
18073 if (temp4)
18074 delete arg4;
18075 }
18076 return NULL;
18077 }
18078
18079
18080 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
18081 PyObject *obj;
18082 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18083 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
18084 Py_INCREF(obj);
18085 return Py_BuildValue((char *)"");
18086 }
18087 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
18088 PyObject *resultobj;
18089 wxPrintData *arg1 = 0 ;
18090 wxPrinterDC *result;
18091 PyObject * obj0 = 0 ;
18092 char *kwnames[] = {
18093 (char *) "printData", NULL
18094 };
18095
18096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
18097 {
18098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18099 if (SWIG_arg_fail(1)) SWIG_fail;
18100 if (arg1 == NULL) {
18101 SWIG_null_ref("wxPrintData");
18102 }
18103 if (SWIG_arg_fail(1)) SWIG_fail;
18104 }
18105 {
18106 if (!wxPyCheckForApp()) SWIG_fail;
18107 PyThreadState* __tstate = wxPyBeginAllowThreads();
18108 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
18109
18110 wxPyEndAllowThreads(__tstate);
18111 if (PyErr_Occurred()) SWIG_fail;
18112 }
18113 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
18114 return resultobj;
18115 fail:
18116 return NULL;
18117 }
18118
18119
18120 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
18121 PyObject *obj;
18122 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18123 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
18124 Py_INCREF(obj);
18125 return Py_BuildValue((char *)"");
18126 }
18127 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18128 PyObject *resultobj;
18129 int arg1 ;
18130 int arg2 ;
18131 int arg3 = (int) true ;
18132 int arg4 = (int) 1 ;
18133 wxImageList *result;
18134 PyObject * obj0 = 0 ;
18135 PyObject * obj1 = 0 ;
18136 PyObject * obj2 = 0 ;
18137 PyObject * obj3 = 0 ;
18138 char *kwnames[] = {
18139 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
18140 };
18141
18142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18143 {
18144 arg1 = (int)(SWIG_As_int(obj0));
18145 if (SWIG_arg_fail(1)) SWIG_fail;
18146 }
18147 {
18148 arg2 = (int)(SWIG_As_int(obj1));
18149 if (SWIG_arg_fail(2)) SWIG_fail;
18150 }
18151 if (obj2) {
18152 {
18153 arg3 = (int)(SWIG_As_int(obj2));
18154 if (SWIG_arg_fail(3)) SWIG_fail;
18155 }
18156 }
18157 if (obj3) {
18158 {
18159 arg4 = (int)(SWIG_As_int(obj3));
18160 if (SWIG_arg_fail(4)) SWIG_fail;
18161 }
18162 }
18163 {
18164 if (!wxPyCheckForApp()) SWIG_fail;
18165 PyThreadState* __tstate = wxPyBeginAllowThreads();
18166 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
18167
18168 wxPyEndAllowThreads(__tstate);
18169 if (PyErr_Occurred()) SWIG_fail;
18170 }
18171 {
18172 resultobj = wxPyMake_wxObject(result, 1);
18173 }
18174 return resultobj;
18175 fail:
18176 return NULL;
18177 }
18178
18179
18180 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18181 PyObject *resultobj;
18182 wxImageList *arg1 = (wxImageList *) 0 ;
18183 PyObject * obj0 = 0 ;
18184 char *kwnames[] = {
18185 (char *) "self", NULL
18186 };
18187
18188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
18189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18190 if (SWIG_arg_fail(1)) SWIG_fail;
18191 {
18192 PyThreadState* __tstate = wxPyBeginAllowThreads();
18193 delete arg1;
18194
18195 wxPyEndAllowThreads(__tstate);
18196 if (PyErr_Occurred()) SWIG_fail;
18197 }
18198 Py_INCREF(Py_None); resultobj = Py_None;
18199 return resultobj;
18200 fail:
18201 return NULL;
18202 }
18203
18204
18205 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
18206 PyObject *resultobj;
18207 wxImageList *arg1 = (wxImageList *) 0 ;
18208 wxBitmap *arg2 = 0 ;
18209 wxBitmap const &arg3_defvalue = wxNullBitmap ;
18210 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
18211 int result;
18212 PyObject * obj0 = 0 ;
18213 PyObject * obj1 = 0 ;
18214 PyObject * obj2 = 0 ;
18215 char *kwnames[] = {
18216 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
18217 };
18218
18219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
18220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18221 if (SWIG_arg_fail(1)) SWIG_fail;
18222 {
18223 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18224 if (SWIG_arg_fail(2)) SWIG_fail;
18225 if (arg2 == NULL) {
18226 SWIG_null_ref("wxBitmap");
18227 }
18228 if (SWIG_arg_fail(2)) SWIG_fail;
18229 }
18230 if (obj2) {
18231 {
18232 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18233 if (SWIG_arg_fail(3)) SWIG_fail;
18234 if (arg3 == NULL) {
18235 SWIG_null_ref("wxBitmap");
18236 }
18237 if (SWIG_arg_fail(3)) SWIG_fail;
18238 }
18239 }
18240 {
18241 PyThreadState* __tstate = wxPyBeginAllowThreads();
18242 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
18243
18244 wxPyEndAllowThreads(__tstate);
18245 if (PyErr_Occurred()) SWIG_fail;
18246 }
18247 {
18248 resultobj = SWIG_From_int((int)(result));
18249 }
18250 return resultobj;
18251 fail:
18252 return NULL;
18253 }
18254
18255
18256 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
18257 PyObject *resultobj;
18258 wxImageList *arg1 = (wxImageList *) 0 ;
18259 wxBitmap *arg2 = 0 ;
18260 wxColour *arg3 = 0 ;
18261 int result;
18262 wxColour temp3 ;
18263 PyObject * obj0 = 0 ;
18264 PyObject * obj1 = 0 ;
18265 PyObject * obj2 = 0 ;
18266 char *kwnames[] = {
18267 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
18268 };
18269
18270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
18271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18272 if (SWIG_arg_fail(1)) SWIG_fail;
18273 {
18274 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18275 if (SWIG_arg_fail(2)) SWIG_fail;
18276 if (arg2 == NULL) {
18277 SWIG_null_ref("wxBitmap");
18278 }
18279 if (SWIG_arg_fail(2)) SWIG_fail;
18280 }
18281 {
18282 arg3 = &temp3;
18283 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
18284 }
18285 {
18286 PyThreadState* __tstate = wxPyBeginAllowThreads();
18287 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
18288
18289 wxPyEndAllowThreads(__tstate);
18290 if (PyErr_Occurred()) SWIG_fail;
18291 }
18292 {
18293 resultobj = SWIG_From_int((int)(result));
18294 }
18295 return resultobj;
18296 fail:
18297 return NULL;
18298 }
18299
18300
18301 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18302 PyObject *resultobj;
18303 wxImageList *arg1 = (wxImageList *) 0 ;
18304 wxIcon *arg2 = 0 ;
18305 int result;
18306 PyObject * obj0 = 0 ;
18307 PyObject * obj1 = 0 ;
18308 char *kwnames[] = {
18309 (char *) "self",(char *) "icon", NULL
18310 };
18311
18312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
18313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18314 if (SWIG_arg_fail(1)) SWIG_fail;
18315 {
18316 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
18317 if (SWIG_arg_fail(2)) SWIG_fail;
18318 if (arg2 == NULL) {
18319 SWIG_null_ref("wxIcon");
18320 }
18321 if (SWIG_arg_fail(2)) SWIG_fail;
18322 }
18323 {
18324 PyThreadState* __tstate = wxPyBeginAllowThreads();
18325 result = (int)(arg1)->Add((wxIcon const &)*arg2);
18326
18327 wxPyEndAllowThreads(__tstate);
18328 if (PyErr_Occurred()) SWIG_fail;
18329 }
18330 {
18331 resultobj = SWIG_From_int((int)(result));
18332 }
18333 return resultobj;
18334 fail:
18335 return NULL;
18336 }
18337
18338
18339 static PyObject *_wrap_ImageList_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
18340 PyObject *resultobj;
18341 wxImageList *arg1 = (wxImageList *) 0 ;
18342 int arg2 ;
18343 SwigValueWrapper<wxBitmap > result;
18344 PyObject * obj0 = 0 ;
18345 PyObject * obj1 = 0 ;
18346 char *kwnames[] = {
18347 (char *) "self",(char *) "index", NULL
18348 };
18349
18350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) goto fail;
18351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18352 if (SWIG_arg_fail(1)) SWIG_fail;
18353 {
18354 arg2 = (int)(SWIG_As_int(obj1));
18355 if (SWIG_arg_fail(2)) SWIG_fail;
18356 }
18357 {
18358 PyThreadState* __tstate = wxPyBeginAllowThreads();
18359 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
18360
18361 wxPyEndAllowThreads(__tstate);
18362 if (PyErr_Occurred()) SWIG_fail;
18363 }
18364 {
18365 wxBitmap * resultptr;
18366 resultptr = new wxBitmap((wxBitmap &)(result));
18367 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
18368 }
18369 return resultobj;
18370 fail:
18371 return NULL;
18372 }
18373
18374
18375 static PyObject *_wrap_ImageList_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18376 PyObject *resultobj;
18377 wxImageList *arg1 = (wxImageList *) 0 ;
18378 int arg2 ;
18379 wxIcon result;
18380 PyObject * obj0 = 0 ;
18381 PyObject * obj1 = 0 ;
18382 char *kwnames[] = {
18383 (char *) "self",(char *) "index", NULL
18384 };
18385
18386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) goto fail;
18387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18388 if (SWIG_arg_fail(1)) SWIG_fail;
18389 {
18390 arg2 = (int)(SWIG_As_int(obj1));
18391 if (SWIG_arg_fail(2)) SWIG_fail;
18392 }
18393 {
18394 PyThreadState* __tstate = wxPyBeginAllowThreads();
18395 result = ((wxImageList const *)arg1)->GetIcon(arg2);
18396
18397 wxPyEndAllowThreads(__tstate);
18398 if (PyErr_Occurred()) SWIG_fail;
18399 }
18400 {
18401 wxIcon * resultptr;
18402 resultptr = new wxIcon((wxIcon &)(result));
18403 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
18404 }
18405 return resultobj;
18406 fail:
18407 return NULL;
18408 }
18409
18410
18411 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
18412 PyObject *resultobj;
18413 wxImageList *arg1 = (wxImageList *) 0 ;
18414 int arg2 ;
18415 wxBitmap *arg3 = 0 ;
18416 bool result;
18417 PyObject * obj0 = 0 ;
18418 PyObject * obj1 = 0 ;
18419 PyObject * obj2 = 0 ;
18420 char *kwnames[] = {
18421 (char *) "self",(char *) "index",(char *) "bitmap", NULL
18422 };
18423
18424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_Replace",kwnames,&obj0,&obj1,&obj2)) goto fail;
18425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18426 if (SWIG_arg_fail(1)) SWIG_fail;
18427 {
18428 arg2 = (int)(SWIG_As_int(obj1));
18429 if (SWIG_arg_fail(2)) SWIG_fail;
18430 }
18431 {
18432 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18433 if (SWIG_arg_fail(3)) SWIG_fail;
18434 if (arg3 == NULL) {
18435 SWIG_null_ref("wxBitmap");
18436 }
18437 if (SWIG_arg_fail(3)) SWIG_fail;
18438 }
18439 {
18440 PyThreadState* __tstate = wxPyBeginAllowThreads();
18441 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3);
18442
18443 wxPyEndAllowThreads(__tstate);
18444 if (PyErr_Occurred()) SWIG_fail;
18445 }
18446 {
18447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18448 }
18449 return resultobj;
18450 fail:
18451 return NULL;
18452 }
18453
18454
18455 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
18456 PyObject *resultobj;
18457 wxImageList *arg1 = (wxImageList *) 0 ;
18458 int arg2 ;
18459 wxDC *arg3 = 0 ;
18460 int arg4 ;
18461 int arg5 ;
18462 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
18463 bool arg7 = (bool) (bool)false ;
18464 bool result;
18465 PyObject * obj0 = 0 ;
18466 PyObject * obj1 = 0 ;
18467 PyObject * obj2 = 0 ;
18468 PyObject * obj3 = 0 ;
18469 PyObject * obj4 = 0 ;
18470 PyObject * obj5 = 0 ;
18471 PyObject * obj6 = 0 ;
18472 char *kwnames[] = {
18473 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
18474 };
18475
18476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
18477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18478 if (SWIG_arg_fail(1)) SWIG_fail;
18479 {
18480 arg2 = (int)(SWIG_As_int(obj1));
18481 if (SWIG_arg_fail(2)) SWIG_fail;
18482 }
18483 {
18484 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18485 if (SWIG_arg_fail(3)) SWIG_fail;
18486 if (arg3 == NULL) {
18487 SWIG_null_ref("wxDC");
18488 }
18489 if (SWIG_arg_fail(3)) SWIG_fail;
18490 }
18491 {
18492 arg4 = (int)(SWIG_As_int(obj3));
18493 if (SWIG_arg_fail(4)) SWIG_fail;
18494 }
18495 {
18496 arg5 = (int)(SWIG_As_int(obj4));
18497 if (SWIG_arg_fail(5)) SWIG_fail;
18498 }
18499 if (obj5) {
18500 {
18501 arg6 = (int)(SWIG_As_int(obj5));
18502 if (SWIG_arg_fail(6)) SWIG_fail;
18503 }
18504 }
18505 if (obj6) {
18506 {
18507 arg7 = (bool const)(SWIG_As_bool(obj6));
18508 if (SWIG_arg_fail(7)) SWIG_fail;
18509 }
18510 }
18511 {
18512 PyThreadState* __tstate = wxPyBeginAllowThreads();
18513 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
18514
18515 wxPyEndAllowThreads(__tstate);
18516 if (PyErr_Occurred()) SWIG_fail;
18517 }
18518 {
18519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18520 }
18521 return resultobj;
18522 fail:
18523 return NULL;
18524 }
18525
18526
18527 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
18528 PyObject *resultobj;
18529 wxImageList *arg1 = (wxImageList *) 0 ;
18530 int result;
18531 PyObject * obj0 = 0 ;
18532 char *kwnames[] = {
18533 (char *) "self", NULL
18534 };
18535
18536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
18537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18538 if (SWIG_arg_fail(1)) SWIG_fail;
18539 {
18540 PyThreadState* __tstate = wxPyBeginAllowThreads();
18541 result = (int)(arg1)->GetImageCount();
18542
18543 wxPyEndAllowThreads(__tstate);
18544 if (PyErr_Occurred()) SWIG_fail;
18545 }
18546 {
18547 resultobj = SWIG_From_int((int)(result));
18548 }
18549 return resultobj;
18550 fail:
18551 return NULL;
18552 }
18553
18554
18555 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
18556 PyObject *resultobj;
18557 wxImageList *arg1 = (wxImageList *) 0 ;
18558 int arg2 ;
18559 bool result;
18560 PyObject * obj0 = 0 ;
18561 PyObject * obj1 = 0 ;
18562 char *kwnames[] = {
18563 (char *) "self",(char *) "index", NULL
18564 };
18565
18566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
18567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18568 if (SWIG_arg_fail(1)) SWIG_fail;
18569 {
18570 arg2 = (int)(SWIG_As_int(obj1));
18571 if (SWIG_arg_fail(2)) SWIG_fail;
18572 }
18573 {
18574 PyThreadState* __tstate = wxPyBeginAllowThreads();
18575 result = (bool)(arg1)->Remove(arg2);
18576
18577 wxPyEndAllowThreads(__tstate);
18578 if (PyErr_Occurred()) SWIG_fail;
18579 }
18580 {
18581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18582 }
18583 return resultobj;
18584 fail:
18585 return NULL;
18586 }
18587
18588
18589 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
18590 PyObject *resultobj;
18591 wxImageList *arg1 = (wxImageList *) 0 ;
18592 bool result;
18593 PyObject * obj0 = 0 ;
18594 char *kwnames[] = {
18595 (char *) "self", NULL
18596 };
18597
18598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
18599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18600 if (SWIG_arg_fail(1)) SWIG_fail;
18601 {
18602 PyThreadState* __tstate = wxPyBeginAllowThreads();
18603 result = (bool)(arg1)->RemoveAll();
18604
18605 wxPyEndAllowThreads(__tstate);
18606 if (PyErr_Occurred()) SWIG_fail;
18607 }
18608 {
18609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18610 }
18611 return resultobj;
18612 fail:
18613 return NULL;
18614 }
18615
18616
18617 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18618 PyObject *resultobj;
18619 wxImageList *arg1 = (wxImageList *) 0 ;
18620 int arg2 ;
18621 int *arg3 = 0 ;
18622 int *arg4 = 0 ;
18623 int temp3 ;
18624 int res3 = 0 ;
18625 int temp4 ;
18626 int res4 = 0 ;
18627 PyObject * obj0 = 0 ;
18628 PyObject * obj1 = 0 ;
18629 char *kwnames[] = {
18630 (char *) "self",(char *) "index", NULL
18631 };
18632
18633 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18634 arg4 = &temp4; res4 = SWIG_NEWOBJ;
18635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
18636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18637 if (SWIG_arg_fail(1)) SWIG_fail;
18638 {
18639 arg2 = (int)(SWIG_As_int(obj1));
18640 if (SWIG_arg_fail(2)) SWIG_fail;
18641 }
18642 {
18643 PyThreadState* __tstate = wxPyBeginAllowThreads();
18644 (arg1)->GetSize(arg2,*arg3,*arg4);
18645
18646 wxPyEndAllowThreads(__tstate);
18647 if (PyErr_Occurred()) SWIG_fail;
18648 }
18649 Py_INCREF(Py_None); resultobj = Py_None;
18650 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18651 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18652 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
18653 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
18654 return resultobj;
18655 fail:
18656 return NULL;
18657 }
18658
18659
18660 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
18661 PyObject *obj;
18662 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18663 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
18664 Py_INCREF(obj);
18665 return Py_BuildValue((char *)"");
18666 }
18667 static int _wrap_NORMAL_FONT_set(PyObject *) {
18668 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
18669 return 1;
18670 }
18671
18672
18673 static PyObject *_wrap_NORMAL_FONT_get(void) {
18674 PyObject *pyobj;
18675
18676 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
18677 return pyobj;
18678 }
18679
18680
18681 static int _wrap_SMALL_FONT_set(PyObject *) {
18682 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
18683 return 1;
18684 }
18685
18686
18687 static PyObject *_wrap_SMALL_FONT_get(void) {
18688 PyObject *pyobj;
18689
18690 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
18691 return pyobj;
18692 }
18693
18694
18695 static int _wrap_ITALIC_FONT_set(PyObject *) {
18696 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
18697 return 1;
18698 }
18699
18700
18701 static PyObject *_wrap_ITALIC_FONT_get(void) {
18702 PyObject *pyobj;
18703
18704 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
18705 return pyobj;
18706 }
18707
18708
18709 static int _wrap_SWISS_FONT_set(PyObject *) {
18710 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
18711 return 1;
18712 }
18713
18714
18715 static PyObject *_wrap_SWISS_FONT_get(void) {
18716 PyObject *pyobj;
18717
18718 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
18719 return pyobj;
18720 }
18721
18722
18723 static int _wrap_RED_PEN_set(PyObject *) {
18724 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
18725 return 1;
18726 }
18727
18728
18729 static PyObject *_wrap_RED_PEN_get(void) {
18730 PyObject *pyobj;
18731
18732 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
18733 return pyobj;
18734 }
18735
18736
18737 static int _wrap_CYAN_PEN_set(PyObject *) {
18738 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
18739 return 1;
18740 }
18741
18742
18743 static PyObject *_wrap_CYAN_PEN_get(void) {
18744 PyObject *pyobj;
18745
18746 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
18747 return pyobj;
18748 }
18749
18750
18751 static int _wrap_GREEN_PEN_set(PyObject *) {
18752 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
18753 return 1;
18754 }
18755
18756
18757 static PyObject *_wrap_GREEN_PEN_get(void) {
18758 PyObject *pyobj;
18759
18760 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
18761 return pyobj;
18762 }
18763
18764
18765 static int _wrap_BLACK_PEN_set(PyObject *) {
18766 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
18767 return 1;
18768 }
18769
18770
18771 static PyObject *_wrap_BLACK_PEN_get(void) {
18772 PyObject *pyobj;
18773
18774 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
18775 return pyobj;
18776 }
18777
18778
18779 static int _wrap_WHITE_PEN_set(PyObject *) {
18780 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
18781 return 1;
18782 }
18783
18784
18785 static PyObject *_wrap_WHITE_PEN_get(void) {
18786 PyObject *pyobj;
18787
18788 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
18789 return pyobj;
18790 }
18791
18792
18793 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
18794 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
18795 return 1;
18796 }
18797
18798
18799 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
18800 PyObject *pyobj;
18801
18802 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
18803 return pyobj;
18804 }
18805
18806
18807 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
18808 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
18809 return 1;
18810 }
18811
18812
18813 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
18814 PyObject *pyobj;
18815
18816 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
18817 return pyobj;
18818 }
18819
18820
18821 static int _wrap_GREY_PEN_set(PyObject *) {
18822 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
18823 return 1;
18824 }
18825
18826
18827 static PyObject *_wrap_GREY_PEN_get(void) {
18828 PyObject *pyobj;
18829
18830 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
18831 return pyobj;
18832 }
18833
18834
18835 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
18836 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
18837 return 1;
18838 }
18839
18840
18841 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
18842 PyObject *pyobj;
18843
18844 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
18845 return pyobj;
18846 }
18847
18848
18849 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
18850 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
18851 return 1;
18852 }
18853
18854
18855 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
18856 PyObject *pyobj;
18857
18858 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
18859 return pyobj;
18860 }
18861
18862
18863 static int _wrap_BLUE_BRUSH_set(PyObject *) {
18864 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
18865 return 1;
18866 }
18867
18868
18869 static PyObject *_wrap_BLUE_BRUSH_get(void) {
18870 PyObject *pyobj;
18871
18872 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
18873 return pyobj;
18874 }
18875
18876
18877 static int _wrap_GREEN_BRUSH_set(PyObject *) {
18878 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
18879 return 1;
18880 }
18881
18882
18883 static PyObject *_wrap_GREEN_BRUSH_get(void) {
18884 PyObject *pyobj;
18885
18886 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
18887 return pyobj;
18888 }
18889
18890
18891 static int _wrap_WHITE_BRUSH_set(PyObject *) {
18892 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
18893 return 1;
18894 }
18895
18896
18897 static PyObject *_wrap_WHITE_BRUSH_get(void) {
18898 PyObject *pyobj;
18899
18900 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
18901 return pyobj;
18902 }
18903
18904
18905 static int _wrap_BLACK_BRUSH_set(PyObject *) {
18906 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
18907 return 1;
18908 }
18909
18910
18911 static PyObject *_wrap_BLACK_BRUSH_get(void) {
18912 PyObject *pyobj;
18913
18914 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
18915 return pyobj;
18916 }
18917
18918
18919 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
18920 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
18921 return 1;
18922 }
18923
18924
18925 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
18926 PyObject *pyobj;
18927
18928 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
18929 return pyobj;
18930 }
18931
18932
18933 static int _wrap_CYAN_BRUSH_set(PyObject *) {
18934 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
18935 return 1;
18936 }
18937
18938
18939 static PyObject *_wrap_CYAN_BRUSH_get(void) {
18940 PyObject *pyobj;
18941
18942 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
18943 return pyobj;
18944 }
18945
18946
18947 static int _wrap_RED_BRUSH_set(PyObject *) {
18948 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
18949 return 1;
18950 }
18951
18952
18953 static PyObject *_wrap_RED_BRUSH_get(void) {
18954 PyObject *pyobj;
18955
18956 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
18957 return pyobj;
18958 }
18959
18960
18961 static int _wrap_GREY_BRUSH_set(PyObject *) {
18962 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
18963 return 1;
18964 }
18965
18966
18967 static PyObject *_wrap_GREY_BRUSH_get(void) {
18968 PyObject *pyobj;
18969
18970 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
18971 return pyobj;
18972 }
18973
18974
18975 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
18976 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
18977 return 1;
18978 }
18979
18980
18981 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
18982 PyObject *pyobj;
18983
18984 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
18985 return pyobj;
18986 }
18987
18988
18989 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
18990 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
18991 return 1;
18992 }
18993
18994
18995 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
18996 PyObject *pyobj;
18997
18998 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
18999 return pyobj;
19000 }
19001
19002
19003 static int _wrap_BLACK_set(PyObject *) {
19004 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
19005 return 1;
19006 }
19007
19008
19009 static PyObject *_wrap_BLACK_get(void) {
19010 PyObject *pyobj;
19011
19012 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
19013 return pyobj;
19014 }
19015
19016
19017 static int _wrap_WHITE_set(PyObject *) {
19018 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
19019 return 1;
19020 }
19021
19022
19023 static PyObject *_wrap_WHITE_get(void) {
19024 PyObject *pyobj;
19025
19026 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
19027 return pyobj;
19028 }
19029
19030
19031 static int _wrap_RED_set(PyObject *) {
19032 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
19033 return 1;
19034 }
19035
19036
19037 static PyObject *_wrap_RED_get(void) {
19038 PyObject *pyobj;
19039
19040 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
19041 return pyobj;
19042 }
19043
19044
19045 static int _wrap_BLUE_set(PyObject *) {
19046 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
19047 return 1;
19048 }
19049
19050
19051 static PyObject *_wrap_BLUE_get(void) {
19052 PyObject *pyobj;
19053
19054 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
19055 return pyobj;
19056 }
19057
19058
19059 static int _wrap_GREEN_set(PyObject *) {
19060 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
19061 return 1;
19062 }
19063
19064
19065 static PyObject *_wrap_GREEN_get(void) {
19066 PyObject *pyobj;
19067
19068 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
19069 return pyobj;
19070 }
19071
19072
19073 static int _wrap_CYAN_set(PyObject *) {
19074 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
19075 return 1;
19076 }
19077
19078
19079 static PyObject *_wrap_CYAN_get(void) {
19080 PyObject *pyobj;
19081
19082 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
19083 return pyobj;
19084 }
19085
19086
19087 static int _wrap_LIGHT_GREY_set(PyObject *) {
19088 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
19089 return 1;
19090 }
19091
19092
19093 static PyObject *_wrap_LIGHT_GREY_get(void) {
19094 PyObject *pyobj;
19095
19096 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
19097 return pyobj;
19098 }
19099
19100
19101 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
19102 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
19103 return 1;
19104 }
19105
19106
19107 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
19108 PyObject *pyobj;
19109
19110 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
19111 return pyobj;
19112 }
19113
19114
19115 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
19116 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
19117 return 1;
19118 }
19119
19120
19121 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
19122 PyObject *pyobj;
19123
19124 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19125 return pyobj;
19126 }
19127
19128
19129 static int _wrap_CROSS_CURSOR_set(PyObject *) {
19130 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
19131 return 1;
19132 }
19133
19134
19135 static PyObject *_wrap_CROSS_CURSOR_get(void) {
19136 PyObject *pyobj;
19137
19138 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19139 return pyobj;
19140 }
19141
19142
19143 static int _wrap_NullBitmap_set(PyObject *) {
19144 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
19145 return 1;
19146 }
19147
19148
19149 static PyObject *_wrap_NullBitmap_get(void) {
19150 PyObject *pyobj;
19151
19152 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
19153 return pyobj;
19154 }
19155
19156
19157 static int _wrap_NullIcon_set(PyObject *) {
19158 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
19159 return 1;
19160 }
19161
19162
19163 static PyObject *_wrap_NullIcon_get(void) {
19164 PyObject *pyobj;
19165
19166 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
19167 return pyobj;
19168 }
19169
19170
19171 static int _wrap_NullCursor_set(PyObject *) {
19172 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
19173 return 1;
19174 }
19175
19176
19177 static PyObject *_wrap_NullCursor_get(void) {
19178 PyObject *pyobj;
19179
19180 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
19181 return pyobj;
19182 }
19183
19184
19185 static int _wrap_NullPen_set(PyObject *) {
19186 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
19187 return 1;
19188 }
19189
19190
19191 static PyObject *_wrap_NullPen_get(void) {
19192 PyObject *pyobj;
19193
19194 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
19195 return pyobj;
19196 }
19197
19198
19199 static int _wrap_NullBrush_set(PyObject *) {
19200 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
19201 return 1;
19202 }
19203
19204
19205 static PyObject *_wrap_NullBrush_get(void) {
19206 PyObject *pyobj;
19207
19208 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
19209 return pyobj;
19210 }
19211
19212
19213 static int _wrap_NullPalette_set(PyObject *) {
19214 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
19215 return 1;
19216 }
19217
19218
19219 static PyObject *_wrap_NullPalette_get(void) {
19220 PyObject *pyobj;
19221
19222 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
19223 return pyobj;
19224 }
19225
19226
19227 static int _wrap_NullFont_set(PyObject *) {
19228 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
19229 return 1;
19230 }
19231
19232
19233 static PyObject *_wrap_NullFont_get(void) {
19234 PyObject *pyobj;
19235
19236 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
19237 return pyobj;
19238 }
19239
19240
19241 static int _wrap_NullColour_set(PyObject *) {
19242 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
19243 return 1;
19244 }
19245
19246
19247 static PyObject *_wrap_NullColour_get(void) {
19248 PyObject *pyobj;
19249
19250 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
19251 return pyobj;
19252 }
19253
19254
19255 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
19256 PyObject *resultobj;
19257 wxPenList *arg1 = (wxPenList *) 0 ;
19258 wxPen *arg2 = (wxPen *) 0 ;
19259 PyObject * obj0 = 0 ;
19260 PyObject * obj1 = 0 ;
19261 char *kwnames[] = {
19262 (char *) "self",(char *) "pen", NULL
19263 };
19264
19265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
19266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19267 if (SWIG_arg_fail(1)) SWIG_fail;
19268 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19269 if (SWIG_arg_fail(2)) SWIG_fail;
19270 {
19271 PyThreadState* __tstate = wxPyBeginAllowThreads();
19272 (arg1)->AddPen(arg2);
19273
19274 wxPyEndAllowThreads(__tstate);
19275 if (PyErr_Occurred()) SWIG_fail;
19276 }
19277 Py_INCREF(Py_None); resultobj = Py_None;
19278 return resultobj;
19279 fail:
19280 return NULL;
19281 }
19282
19283
19284 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
19285 PyObject *resultobj;
19286 wxPenList *arg1 = (wxPenList *) 0 ;
19287 wxColour *arg2 = 0 ;
19288 int arg3 ;
19289 int arg4 ;
19290 wxPen *result;
19291 wxColour temp2 ;
19292 PyObject * obj0 = 0 ;
19293 PyObject * obj1 = 0 ;
19294 PyObject * obj2 = 0 ;
19295 PyObject * obj3 = 0 ;
19296 char *kwnames[] = {
19297 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
19298 };
19299
19300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19302 if (SWIG_arg_fail(1)) SWIG_fail;
19303 {
19304 arg2 = &temp2;
19305 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19306 }
19307 {
19308 arg3 = (int)(SWIG_As_int(obj2));
19309 if (SWIG_arg_fail(3)) SWIG_fail;
19310 }
19311 {
19312 arg4 = (int)(SWIG_As_int(obj3));
19313 if (SWIG_arg_fail(4)) SWIG_fail;
19314 }
19315 {
19316 PyThreadState* __tstate = wxPyBeginAllowThreads();
19317 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
19318
19319 wxPyEndAllowThreads(__tstate);
19320 if (PyErr_Occurred()) SWIG_fail;
19321 }
19322 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
19323 return resultobj;
19324 fail:
19325 return NULL;
19326 }
19327
19328
19329 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
19330 PyObject *resultobj;
19331 wxPenList *arg1 = (wxPenList *) 0 ;
19332 wxPen *arg2 = (wxPen *) 0 ;
19333 PyObject * obj0 = 0 ;
19334 PyObject * obj1 = 0 ;
19335 char *kwnames[] = {
19336 (char *) "self",(char *) "pen", NULL
19337 };
19338
19339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
19340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19341 if (SWIG_arg_fail(1)) SWIG_fail;
19342 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19343 if (SWIG_arg_fail(2)) SWIG_fail;
19344 {
19345 PyThreadState* __tstate = wxPyBeginAllowThreads();
19346 (arg1)->RemovePen(arg2);
19347
19348 wxPyEndAllowThreads(__tstate);
19349 if (PyErr_Occurred()) SWIG_fail;
19350 }
19351 Py_INCREF(Py_None); resultobj = Py_None;
19352 return resultobj;
19353 fail:
19354 return NULL;
19355 }
19356
19357
19358 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19359 PyObject *resultobj;
19360 wxPenList *arg1 = (wxPenList *) 0 ;
19361 int result;
19362 PyObject * obj0 = 0 ;
19363 char *kwnames[] = {
19364 (char *) "self", NULL
19365 };
19366
19367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
19368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19369 if (SWIG_arg_fail(1)) SWIG_fail;
19370 {
19371 PyThreadState* __tstate = wxPyBeginAllowThreads();
19372 result = (int)(arg1)->GetCount();
19373
19374 wxPyEndAllowThreads(__tstate);
19375 if (PyErr_Occurred()) SWIG_fail;
19376 }
19377 {
19378 resultobj = SWIG_From_int((int)(result));
19379 }
19380 return resultobj;
19381 fail:
19382 return NULL;
19383 }
19384
19385
19386 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
19387 PyObject *obj;
19388 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19389 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
19390 Py_INCREF(obj);
19391 return Py_BuildValue((char *)"");
19392 }
19393 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19394 PyObject *resultobj;
19395 wxBrushList *arg1 = (wxBrushList *) 0 ;
19396 wxBrush *arg2 = (wxBrush *) 0 ;
19397 PyObject * obj0 = 0 ;
19398 PyObject * obj1 = 0 ;
19399 char *kwnames[] = {
19400 (char *) "self",(char *) "brush", NULL
19401 };
19402
19403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
19404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19405 if (SWIG_arg_fail(1)) SWIG_fail;
19406 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19407 if (SWIG_arg_fail(2)) SWIG_fail;
19408 {
19409 PyThreadState* __tstate = wxPyBeginAllowThreads();
19410 (arg1)->AddBrush(arg2);
19411
19412 wxPyEndAllowThreads(__tstate);
19413 if (PyErr_Occurred()) SWIG_fail;
19414 }
19415 Py_INCREF(Py_None); resultobj = Py_None;
19416 return resultobj;
19417 fail:
19418 return NULL;
19419 }
19420
19421
19422 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19423 PyObject *resultobj;
19424 wxBrushList *arg1 = (wxBrushList *) 0 ;
19425 wxColour *arg2 = 0 ;
19426 int arg3 = (int) wxSOLID ;
19427 wxBrush *result;
19428 wxColour temp2 ;
19429 PyObject * obj0 = 0 ;
19430 PyObject * obj1 = 0 ;
19431 PyObject * obj2 = 0 ;
19432 char *kwnames[] = {
19433 (char *) "self",(char *) "colour",(char *) "style", NULL
19434 };
19435
19436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
19437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19438 if (SWIG_arg_fail(1)) SWIG_fail;
19439 {
19440 arg2 = &temp2;
19441 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19442 }
19443 if (obj2) {
19444 {
19445 arg3 = (int)(SWIG_As_int(obj2));
19446 if (SWIG_arg_fail(3)) SWIG_fail;
19447 }
19448 }
19449 {
19450 PyThreadState* __tstate = wxPyBeginAllowThreads();
19451 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
19452
19453 wxPyEndAllowThreads(__tstate);
19454 if (PyErr_Occurred()) SWIG_fail;
19455 }
19456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
19457 return resultobj;
19458 fail:
19459 return NULL;
19460 }
19461
19462
19463 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19464 PyObject *resultobj;
19465 wxBrushList *arg1 = (wxBrushList *) 0 ;
19466 wxBrush *arg2 = (wxBrush *) 0 ;
19467 PyObject * obj0 = 0 ;
19468 PyObject * obj1 = 0 ;
19469 char *kwnames[] = {
19470 (char *) "self",(char *) "brush", NULL
19471 };
19472
19473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
19474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19475 if (SWIG_arg_fail(1)) SWIG_fail;
19476 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19477 if (SWIG_arg_fail(2)) SWIG_fail;
19478 {
19479 PyThreadState* __tstate = wxPyBeginAllowThreads();
19480 (arg1)->RemoveBrush(arg2);
19481
19482 wxPyEndAllowThreads(__tstate);
19483 if (PyErr_Occurred()) SWIG_fail;
19484 }
19485 Py_INCREF(Py_None); resultobj = Py_None;
19486 return resultobj;
19487 fail:
19488 return NULL;
19489 }
19490
19491
19492 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19493 PyObject *resultobj;
19494 wxBrushList *arg1 = (wxBrushList *) 0 ;
19495 int result;
19496 PyObject * obj0 = 0 ;
19497 char *kwnames[] = {
19498 (char *) "self", NULL
19499 };
19500
19501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
19502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19503 if (SWIG_arg_fail(1)) SWIG_fail;
19504 {
19505 PyThreadState* __tstate = wxPyBeginAllowThreads();
19506 result = (int)(arg1)->GetCount();
19507
19508 wxPyEndAllowThreads(__tstate);
19509 if (PyErr_Occurred()) SWIG_fail;
19510 }
19511 {
19512 resultobj = SWIG_From_int((int)(result));
19513 }
19514 return resultobj;
19515 fail:
19516 return NULL;
19517 }
19518
19519
19520 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
19521 PyObject *obj;
19522 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19523 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
19524 Py_INCREF(obj);
19525 return Py_BuildValue((char *)"");
19526 }
19527 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19528 PyObject *resultobj;
19529 wxColourDatabase *result;
19530 char *kwnames[] = {
19531 NULL
19532 };
19533
19534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
19535 {
19536 if (!wxPyCheckForApp()) SWIG_fail;
19537 PyThreadState* __tstate = wxPyBeginAllowThreads();
19538 result = (wxColourDatabase *)new wxColourDatabase();
19539
19540 wxPyEndAllowThreads(__tstate);
19541 if (PyErr_Occurred()) SWIG_fail;
19542 }
19543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
19544 return resultobj;
19545 fail:
19546 return NULL;
19547 }
19548
19549
19550 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19551 PyObject *resultobj;
19552 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19553 PyObject * obj0 = 0 ;
19554 char *kwnames[] = {
19555 (char *) "self", NULL
19556 };
19557
19558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
19559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19560 if (SWIG_arg_fail(1)) SWIG_fail;
19561 {
19562 PyThreadState* __tstate = wxPyBeginAllowThreads();
19563 delete arg1;
19564
19565 wxPyEndAllowThreads(__tstate);
19566 if (PyErr_Occurred()) SWIG_fail;
19567 }
19568 Py_INCREF(Py_None); resultobj = Py_None;
19569 return resultobj;
19570 fail:
19571 return NULL;
19572 }
19573
19574
19575 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
19576 PyObject *resultobj;
19577 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19578 wxString *arg2 = 0 ;
19579 wxColour result;
19580 bool temp2 = false ;
19581 PyObject * obj0 = 0 ;
19582 PyObject * obj1 = 0 ;
19583 char *kwnames[] = {
19584 (char *) "self",(char *) "name", NULL
19585 };
19586
19587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
19588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19589 if (SWIG_arg_fail(1)) SWIG_fail;
19590 {
19591 arg2 = wxString_in_helper(obj1);
19592 if (arg2 == NULL) SWIG_fail;
19593 temp2 = true;
19594 }
19595 {
19596 PyThreadState* __tstate = wxPyBeginAllowThreads();
19597 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
19598
19599 wxPyEndAllowThreads(__tstate);
19600 if (PyErr_Occurred()) SWIG_fail;
19601 }
19602 {
19603 wxColour * resultptr;
19604 resultptr = new wxColour((wxColour &)(result));
19605 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19606 }
19607 {
19608 if (temp2)
19609 delete arg2;
19610 }
19611 return resultobj;
19612 fail:
19613 {
19614 if (temp2)
19615 delete arg2;
19616 }
19617 return NULL;
19618 }
19619
19620
19621 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
19622 PyObject *resultobj;
19623 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19624 wxColour *arg2 = 0 ;
19625 wxString result;
19626 wxColour temp2 ;
19627 PyObject * obj0 = 0 ;
19628 PyObject * obj1 = 0 ;
19629 char *kwnames[] = {
19630 (char *) "self",(char *) "colour", NULL
19631 };
19632
19633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
19634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19635 if (SWIG_arg_fail(1)) SWIG_fail;
19636 {
19637 arg2 = &temp2;
19638 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19639 }
19640 {
19641 PyThreadState* __tstate = wxPyBeginAllowThreads();
19642 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
19643
19644 wxPyEndAllowThreads(__tstate);
19645 if (PyErr_Occurred()) SWIG_fail;
19646 }
19647 {
19648 #if wxUSE_UNICODE
19649 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19650 #else
19651 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19652 #endif
19653 }
19654 return resultobj;
19655 fail:
19656 return NULL;
19657 }
19658
19659
19660 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
19661 PyObject *resultobj;
19662 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19663 wxString *arg2 = 0 ;
19664 wxColour *arg3 = 0 ;
19665 bool temp2 = false ;
19666 wxColour temp3 ;
19667 PyObject * obj0 = 0 ;
19668 PyObject * obj1 = 0 ;
19669 PyObject * obj2 = 0 ;
19670 char *kwnames[] = {
19671 (char *) "self",(char *) "name",(char *) "colour", NULL
19672 };
19673
19674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
19675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19676 if (SWIG_arg_fail(1)) SWIG_fail;
19677 {
19678 arg2 = wxString_in_helper(obj1);
19679 if (arg2 == NULL) SWIG_fail;
19680 temp2 = true;
19681 }
19682 {
19683 arg3 = &temp3;
19684 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19685 }
19686 {
19687 PyThreadState* __tstate = wxPyBeginAllowThreads();
19688 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
19689
19690 wxPyEndAllowThreads(__tstate);
19691 if (PyErr_Occurred()) SWIG_fail;
19692 }
19693 Py_INCREF(Py_None); resultobj = Py_None;
19694 {
19695 if (temp2)
19696 delete arg2;
19697 }
19698 return resultobj;
19699 fail:
19700 {
19701 if (temp2)
19702 delete arg2;
19703 }
19704 return NULL;
19705 }
19706
19707
19708 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
19709 PyObject *resultobj;
19710 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19711 wxString *arg2 = 0 ;
19712 int arg3 ;
19713 int arg4 ;
19714 int arg5 ;
19715 bool temp2 = false ;
19716 PyObject * obj0 = 0 ;
19717 PyObject * obj1 = 0 ;
19718 PyObject * obj2 = 0 ;
19719 PyObject * obj3 = 0 ;
19720 PyObject * obj4 = 0 ;
19721 char *kwnames[] = {
19722 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
19723 };
19724
19725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19727 if (SWIG_arg_fail(1)) SWIG_fail;
19728 {
19729 arg2 = wxString_in_helper(obj1);
19730 if (arg2 == NULL) SWIG_fail;
19731 temp2 = true;
19732 }
19733 {
19734 arg3 = (int)(SWIG_As_int(obj2));
19735 if (SWIG_arg_fail(3)) SWIG_fail;
19736 }
19737 {
19738 arg4 = (int)(SWIG_As_int(obj3));
19739 if (SWIG_arg_fail(4)) SWIG_fail;
19740 }
19741 {
19742 arg5 = (int)(SWIG_As_int(obj4));
19743 if (SWIG_arg_fail(5)) SWIG_fail;
19744 }
19745 {
19746 PyThreadState* __tstate = wxPyBeginAllowThreads();
19747 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
19748
19749 wxPyEndAllowThreads(__tstate);
19750 if (PyErr_Occurred()) SWIG_fail;
19751 }
19752 Py_INCREF(Py_None); resultobj = Py_None;
19753 {
19754 if (temp2)
19755 delete arg2;
19756 }
19757 return resultobj;
19758 fail:
19759 {
19760 if (temp2)
19761 delete arg2;
19762 }
19763 return NULL;
19764 }
19765
19766
19767 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
19768 PyObject *obj;
19769 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19770 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
19771 Py_INCREF(obj);
19772 return Py_BuildValue((char *)"");
19773 }
19774 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
19775 PyObject *resultobj;
19776 wxFontList *arg1 = (wxFontList *) 0 ;
19777 wxFont *arg2 = (wxFont *) 0 ;
19778 PyObject * obj0 = 0 ;
19779 PyObject * obj1 = 0 ;
19780 char *kwnames[] = {
19781 (char *) "self",(char *) "font", NULL
19782 };
19783
19784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
19785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19786 if (SWIG_arg_fail(1)) SWIG_fail;
19787 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19788 if (SWIG_arg_fail(2)) SWIG_fail;
19789 {
19790 PyThreadState* __tstate = wxPyBeginAllowThreads();
19791 (arg1)->AddFont(arg2);
19792
19793 wxPyEndAllowThreads(__tstate);
19794 if (PyErr_Occurred()) SWIG_fail;
19795 }
19796 Py_INCREF(Py_None); resultobj = Py_None;
19797 return resultobj;
19798 fail:
19799 return NULL;
19800 }
19801
19802
19803 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
19804 PyObject *resultobj;
19805 wxFontList *arg1 = (wxFontList *) 0 ;
19806 int arg2 ;
19807 int arg3 ;
19808 int arg4 ;
19809 int arg5 ;
19810 bool arg6 = (bool) false ;
19811 wxString const &arg7_defvalue = wxPyEmptyString ;
19812 wxString *arg7 = (wxString *) &arg7_defvalue ;
19813 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
19814 wxFont *result;
19815 bool temp7 = false ;
19816 PyObject * obj0 = 0 ;
19817 PyObject * obj1 = 0 ;
19818 PyObject * obj2 = 0 ;
19819 PyObject * obj3 = 0 ;
19820 PyObject * obj4 = 0 ;
19821 PyObject * obj5 = 0 ;
19822 PyObject * obj6 = 0 ;
19823 PyObject * obj7 = 0 ;
19824 char *kwnames[] = {
19825 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
19826 };
19827
19828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19830 if (SWIG_arg_fail(1)) SWIG_fail;
19831 {
19832 arg2 = (int)(SWIG_As_int(obj1));
19833 if (SWIG_arg_fail(2)) SWIG_fail;
19834 }
19835 {
19836 arg3 = (int)(SWIG_As_int(obj2));
19837 if (SWIG_arg_fail(3)) SWIG_fail;
19838 }
19839 {
19840 arg4 = (int)(SWIG_As_int(obj3));
19841 if (SWIG_arg_fail(4)) SWIG_fail;
19842 }
19843 {
19844 arg5 = (int)(SWIG_As_int(obj4));
19845 if (SWIG_arg_fail(5)) SWIG_fail;
19846 }
19847 if (obj5) {
19848 {
19849 arg6 = (bool)(SWIG_As_bool(obj5));
19850 if (SWIG_arg_fail(6)) SWIG_fail;
19851 }
19852 }
19853 if (obj6) {
19854 {
19855 arg7 = wxString_in_helper(obj6);
19856 if (arg7 == NULL) SWIG_fail;
19857 temp7 = true;
19858 }
19859 }
19860 if (obj7) {
19861 {
19862 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
19863 if (SWIG_arg_fail(8)) SWIG_fail;
19864 }
19865 }
19866 {
19867 PyThreadState* __tstate = wxPyBeginAllowThreads();
19868 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
19869
19870 wxPyEndAllowThreads(__tstate);
19871 if (PyErr_Occurred()) SWIG_fail;
19872 }
19873 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
19874 {
19875 if (temp7)
19876 delete arg7;
19877 }
19878 return resultobj;
19879 fail:
19880 {
19881 if (temp7)
19882 delete arg7;
19883 }
19884 return NULL;
19885 }
19886
19887
19888 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
19889 PyObject *resultobj;
19890 wxFontList *arg1 = (wxFontList *) 0 ;
19891 wxFont *arg2 = (wxFont *) 0 ;
19892 PyObject * obj0 = 0 ;
19893 PyObject * obj1 = 0 ;
19894 char *kwnames[] = {
19895 (char *) "self",(char *) "font", NULL
19896 };
19897
19898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
19899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19900 if (SWIG_arg_fail(1)) SWIG_fail;
19901 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19902 if (SWIG_arg_fail(2)) SWIG_fail;
19903 {
19904 PyThreadState* __tstate = wxPyBeginAllowThreads();
19905 (arg1)->RemoveFont(arg2);
19906
19907 wxPyEndAllowThreads(__tstate);
19908 if (PyErr_Occurred()) SWIG_fail;
19909 }
19910 Py_INCREF(Py_None); resultobj = Py_None;
19911 return resultobj;
19912 fail:
19913 return NULL;
19914 }
19915
19916
19917 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19918 PyObject *resultobj;
19919 wxFontList *arg1 = (wxFontList *) 0 ;
19920 int result;
19921 PyObject * obj0 = 0 ;
19922 char *kwnames[] = {
19923 (char *) "self", NULL
19924 };
19925
19926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
19927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19928 if (SWIG_arg_fail(1)) SWIG_fail;
19929 {
19930 PyThreadState* __tstate = wxPyBeginAllowThreads();
19931 result = (int)(arg1)->GetCount();
19932
19933 wxPyEndAllowThreads(__tstate);
19934 if (PyErr_Occurred()) SWIG_fail;
19935 }
19936 {
19937 resultobj = SWIG_From_int((int)(result));
19938 }
19939 return resultobj;
19940 fail:
19941 return NULL;
19942 }
19943
19944
19945 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
19946 PyObject *obj;
19947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19948 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
19949 Py_INCREF(obj);
19950 return Py_BuildValue((char *)"");
19951 }
19952 static int _wrap_TheFontList_set(PyObject *) {
19953 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
19954 return 1;
19955 }
19956
19957
19958 static PyObject *_wrap_TheFontList_get(void) {
19959 PyObject *pyobj;
19960
19961 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
19962 return pyobj;
19963 }
19964
19965
19966 static int _wrap_ThePenList_set(PyObject *) {
19967 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
19968 return 1;
19969 }
19970
19971
19972 static PyObject *_wrap_ThePenList_get(void) {
19973 PyObject *pyobj;
19974
19975 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
19976 return pyobj;
19977 }
19978
19979
19980 static int _wrap_TheBrushList_set(PyObject *) {
19981 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
19982 return 1;
19983 }
19984
19985
19986 static PyObject *_wrap_TheBrushList_get(void) {
19987 PyObject *pyobj;
19988
19989 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
19990 return pyobj;
19991 }
19992
19993
19994 static int _wrap_TheColourDatabase_set(PyObject *) {
19995 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
19996 return 1;
19997 }
19998
19999
20000 static PyObject *_wrap_TheColourDatabase_get(void) {
20001 PyObject *pyobj;
20002
20003 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
20004 return pyobj;
20005 }
20006
20007
20008 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
20009 PyObject *resultobj;
20010 wxEffects *result;
20011 char *kwnames[] = {
20012 NULL
20013 };
20014
20015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
20016 {
20017 PyThreadState* __tstate = wxPyBeginAllowThreads();
20018 result = (wxEffects *)new wxEffects();
20019
20020 wxPyEndAllowThreads(__tstate);
20021 if (PyErr_Occurred()) SWIG_fail;
20022 }
20023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
20024 return resultobj;
20025 fail:
20026 return NULL;
20027 }
20028
20029
20030 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20031 PyObject *resultobj;
20032 wxEffects *arg1 = (wxEffects *) 0 ;
20033 wxColour result;
20034 PyObject * obj0 = 0 ;
20035 char *kwnames[] = {
20036 (char *) "self", NULL
20037 };
20038
20039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
20040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20041 if (SWIG_arg_fail(1)) SWIG_fail;
20042 {
20043 PyThreadState* __tstate = wxPyBeginAllowThreads();
20044 result = ((wxEffects const *)arg1)->GetHighlightColour();
20045
20046 wxPyEndAllowThreads(__tstate);
20047 if (PyErr_Occurred()) SWIG_fail;
20048 }
20049 {
20050 wxColour * resultptr;
20051 resultptr = new wxColour((wxColour &)(result));
20052 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20053 }
20054 return resultobj;
20055 fail:
20056 return NULL;
20057 }
20058
20059
20060 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20061 PyObject *resultobj;
20062 wxEffects *arg1 = (wxEffects *) 0 ;
20063 wxColour result;
20064 PyObject * obj0 = 0 ;
20065 char *kwnames[] = {
20066 (char *) "self", NULL
20067 };
20068
20069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
20070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20071 if (SWIG_arg_fail(1)) SWIG_fail;
20072 {
20073 PyThreadState* __tstate = wxPyBeginAllowThreads();
20074 result = ((wxEffects const *)arg1)->GetLightShadow();
20075
20076 wxPyEndAllowThreads(__tstate);
20077 if (PyErr_Occurred()) SWIG_fail;
20078 }
20079 {
20080 wxColour * resultptr;
20081 resultptr = new wxColour((wxColour &)(result));
20082 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20083 }
20084 return resultobj;
20085 fail:
20086 return NULL;
20087 }
20088
20089
20090 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20091 PyObject *resultobj;
20092 wxEffects *arg1 = (wxEffects *) 0 ;
20093 wxColour result;
20094 PyObject * obj0 = 0 ;
20095 char *kwnames[] = {
20096 (char *) "self", NULL
20097 };
20098
20099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
20100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20101 if (SWIG_arg_fail(1)) SWIG_fail;
20102 {
20103 PyThreadState* __tstate = wxPyBeginAllowThreads();
20104 result = ((wxEffects const *)arg1)->GetFaceColour();
20105
20106 wxPyEndAllowThreads(__tstate);
20107 if (PyErr_Occurred()) SWIG_fail;
20108 }
20109 {
20110 wxColour * resultptr;
20111 resultptr = new wxColour((wxColour &)(result));
20112 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20113 }
20114 return resultobj;
20115 fail:
20116 return NULL;
20117 }
20118
20119
20120 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20121 PyObject *resultobj;
20122 wxEffects *arg1 = (wxEffects *) 0 ;
20123 wxColour result;
20124 PyObject * obj0 = 0 ;
20125 char *kwnames[] = {
20126 (char *) "self", NULL
20127 };
20128
20129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
20130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20131 if (SWIG_arg_fail(1)) SWIG_fail;
20132 {
20133 PyThreadState* __tstate = wxPyBeginAllowThreads();
20134 result = ((wxEffects const *)arg1)->GetMediumShadow();
20135
20136 wxPyEndAllowThreads(__tstate);
20137 if (PyErr_Occurred()) SWIG_fail;
20138 }
20139 {
20140 wxColour * resultptr;
20141 resultptr = new wxColour((wxColour &)(result));
20142 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20143 }
20144 return resultobj;
20145 fail:
20146 return NULL;
20147 }
20148
20149
20150 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20151 PyObject *resultobj;
20152 wxEffects *arg1 = (wxEffects *) 0 ;
20153 wxColour result;
20154 PyObject * obj0 = 0 ;
20155 char *kwnames[] = {
20156 (char *) "self", NULL
20157 };
20158
20159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
20160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20161 if (SWIG_arg_fail(1)) SWIG_fail;
20162 {
20163 PyThreadState* __tstate = wxPyBeginAllowThreads();
20164 result = ((wxEffects const *)arg1)->GetDarkShadow();
20165
20166 wxPyEndAllowThreads(__tstate);
20167 if (PyErr_Occurred()) SWIG_fail;
20168 }
20169 {
20170 wxColour * resultptr;
20171 resultptr = new wxColour((wxColour &)(result));
20172 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20173 }
20174 return resultobj;
20175 fail:
20176 return NULL;
20177 }
20178
20179
20180 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20181 PyObject *resultobj;
20182 wxEffects *arg1 = (wxEffects *) 0 ;
20183 wxColour *arg2 = 0 ;
20184 wxColour temp2 ;
20185 PyObject * obj0 = 0 ;
20186 PyObject * obj1 = 0 ;
20187 char *kwnames[] = {
20188 (char *) "self",(char *) "c", NULL
20189 };
20190
20191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
20192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20193 if (SWIG_arg_fail(1)) SWIG_fail;
20194 {
20195 arg2 = &temp2;
20196 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20197 }
20198 {
20199 PyThreadState* __tstate = wxPyBeginAllowThreads();
20200 (arg1)->SetHighlightColour((wxColour const &)*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_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20213 PyObject *resultobj;
20214 wxEffects *arg1 = (wxEffects *) 0 ;
20215 wxColour *arg2 = 0 ;
20216 wxColour temp2 ;
20217 PyObject * obj0 = 0 ;
20218 PyObject * obj1 = 0 ;
20219 char *kwnames[] = {
20220 (char *) "self",(char *) "c", NULL
20221 };
20222
20223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
20224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20225 if (SWIG_arg_fail(1)) SWIG_fail;
20226 {
20227 arg2 = &temp2;
20228 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20229 }
20230 {
20231 PyThreadState* __tstate = wxPyBeginAllowThreads();
20232 (arg1)->SetLightShadow((wxColour const &)*arg2);
20233
20234 wxPyEndAllowThreads(__tstate);
20235 if (PyErr_Occurred()) SWIG_fail;
20236 }
20237 Py_INCREF(Py_None); resultobj = Py_None;
20238 return resultobj;
20239 fail:
20240 return NULL;
20241 }
20242
20243
20244 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20245 PyObject *resultobj;
20246 wxEffects *arg1 = (wxEffects *) 0 ;
20247 wxColour *arg2 = 0 ;
20248 wxColour temp2 ;
20249 PyObject * obj0 = 0 ;
20250 PyObject * obj1 = 0 ;
20251 char *kwnames[] = {
20252 (char *) "self",(char *) "c", NULL
20253 };
20254
20255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
20256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20257 if (SWIG_arg_fail(1)) SWIG_fail;
20258 {
20259 arg2 = &temp2;
20260 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20261 }
20262 {
20263 PyThreadState* __tstate = wxPyBeginAllowThreads();
20264 (arg1)->SetFaceColour((wxColour const &)*arg2);
20265
20266 wxPyEndAllowThreads(__tstate);
20267 if (PyErr_Occurred()) SWIG_fail;
20268 }
20269 Py_INCREF(Py_None); resultobj = Py_None;
20270 return resultobj;
20271 fail:
20272 return NULL;
20273 }
20274
20275
20276 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20277 PyObject *resultobj;
20278 wxEffects *arg1 = (wxEffects *) 0 ;
20279 wxColour *arg2 = 0 ;
20280 wxColour temp2 ;
20281 PyObject * obj0 = 0 ;
20282 PyObject * obj1 = 0 ;
20283 char *kwnames[] = {
20284 (char *) "self",(char *) "c", NULL
20285 };
20286
20287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
20288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20289 if (SWIG_arg_fail(1)) SWIG_fail;
20290 {
20291 arg2 = &temp2;
20292 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20293 }
20294 {
20295 PyThreadState* __tstate = wxPyBeginAllowThreads();
20296 (arg1)->SetMediumShadow((wxColour const &)*arg2);
20297
20298 wxPyEndAllowThreads(__tstate);
20299 if (PyErr_Occurred()) SWIG_fail;
20300 }
20301 Py_INCREF(Py_None); resultobj = Py_None;
20302 return resultobj;
20303 fail:
20304 return NULL;
20305 }
20306
20307
20308 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20309 PyObject *resultobj;
20310 wxEffects *arg1 = (wxEffects *) 0 ;
20311 wxColour *arg2 = 0 ;
20312 wxColour temp2 ;
20313 PyObject * obj0 = 0 ;
20314 PyObject * obj1 = 0 ;
20315 char *kwnames[] = {
20316 (char *) "self",(char *) "c", NULL
20317 };
20318
20319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
20320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20321 if (SWIG_arg_fail(1)) SWIG_fail;
20322 {
20323 arg2 = &temp2;
20324 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20325 }
20326 {
20327 PyThreadState* __tstate = wxPyBeginAllowThreads();
20328 (arg1)->SetDarkShadow((wxColour const &)*arg2);
20329
20330 wxPyEndAllowThreads(__tstate);
20331 if (PyErr_Occurred()) SWIG_fail;
20332 }
20333 Py_INCREF(Py_None); resultobj = Py_None;
20334 return resultobj;
20335 fail:
20336 return NULL;
20337 }
20338
20339
20340 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20341 PyObject *resultobj;
20342 wxEffects *arg1 = (wxEffects *) 0 ;
20343 wxColour *arg2 = 0 ;
20344 wxColour *arg3 = 0 ;
20345 wxColour *arg4 = 0 ;
20346 wxColour *arg5 = 0 ;
20347 wxColour *arg6 = 0 ;
20348 wxColour temp2 ;
20349 wxColour temp3 ;
20350 wxColour temp4 ;
20351 wxColour temp5 ;
20352 wxColour temp6 ;
20353 PyObject * obj0 = 0 ;
20354 PyObject * obj1 = 0 ;
20355 PyObject * obj2 = 0 ;
20356 PyObject * obj3 = 0 ;
20357 PyObject * obj4 = 0 ;
20358 PyObject * obj5 = 0 ;
20359 char *kwnames[] = {
20360 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
20361 };
20362
20363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
20364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20365 if (SWIG_arg_fail(1)) SWIG_fail;
20366 {
20367 arg2 = &temp2;
20368 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20369 }
20370 {
20371 arg3 = &temp3;
20372 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20373 }
20374 {
20375 arg4 = &temp4;
20376 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
20377 }
20378 {
20379 arg5 = &temp5;
20380 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
20381 }
20382 {
20383 arg6 = &temp6;
20384 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
20385 }
20386 {
20387 PyThreadState* __tstate = wxPyBeginAllowThreads();
20388 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
20389
20390 wxPyEndAllowThreads(__tstate);
20391 if (PyErr_Occurred()) SWIG_fail;
20392 }
20393 Py_INCREF(Py_None); resultobj = Py_None;
20394 return resultobj;
20395 fail:
20396 return NULL;
20397 }
20398
20399
20400 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
20401 PyObject *resultobj;
20402 wxEffects *arg1 = (wxEffects *) 0 ;
20403 wxDC *arg2 = 0 ;
20404 wxRect *arg3 = 0 ;
20405 int arg4 = (int) 1 ;
20406 wxRect temp3 ;
20407 PyObject * obj0 = 0 ;
20408 PyObject * obj1 = 0 ;
20409 PyObject * obj2 = 0 ;
20410 PyObject * obj3 = 0 ;
20411 char *kwnames[] = {
20412 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
20413 };
20414
20415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20417 if (SWIG_arg_fail(1)) SWIG_fail;
20418 {
20419 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20420 if (SWIG_arg_fail(2)) SWIG_fail;
20421 if (arg2 == NULL) {
20422 SWIG_null_ref("wxDC");
20423 }
20424 if (SWIG_arg_fail(2)) SWIG_fail;
20425 }
20426 {
20427 arg3 = &temp3;
20428 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
20429 }
20430 if (obj3) {
20431 {
20432 arg4 = (int)(SWIG_As_int(obj3));
20433 if (SWIG_arg_fail(4)) SWIG_fail;
20434 }
20435 }
20436 {
20437 PyThreadState* __tstate = wxPyBeginAllowThreads();
20438 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
20439
20440 wxPyEndAllowThreads(__tstate);
20441 if (PyErr_Occurred()) SWIG_fail;
20442 }
20443 Py_INCREF(Py_None); resultobj = Py_None;
20444 return resultobj;
20445 fail:
20446 return NULL;
20447 }
20448
20449
20450 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
20451 PyObject *resultobj;
20452 wxEffects *arg1 = (wxEffects *) 0 ;
20453 wxRect *arg2 = 0 ;
20454 wxDC *arg3 = 0 ;
20455 wxBitmap *arg4 = 0 ;
20456 bool result;
20457 wxRect temp2 ;
20458 PyObject * obj0 = 0 ;
20459 PyObject * obj1 = 0 ;
20460 PyObject * obj2 = 0 ;
20461 PyObject * obj3 = 0 ;
20462 char *kwnames[] = {
20463 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
20464 };
20465
20466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20468 if (SWIG_arg_fail(1)) SWIG_fail;
20469 {
20470 arg2 = &temp2;
20471 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20472 }
20473 {
20474 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20475 if (SWIG_arg_fail(3)) SWIG_fail;
20476 if (arg3 == NULL) {
20477 SWIG_null_ref("wxDC");
20478 }
20479 if (SWIG_arg_fail(3)) SWIG_fail;
20480 }
20481 {
20482 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
20483 if (SWIG_arg_fail(4)) SWIG_fail;
20484 if (arg4 == NULL) {
20485 SWIG_null_ref("wxBitmap");
20486 }
20487 if (SWIG_arg_fail(4)) SWIG_fail;
20488 }
20489 {
20490 PyThreadState* __tstate = wxPyBeginAllowThreads();
20491 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
20492
20493 wxPyEndAllowThreads(__tstate);
20494 if (PyErr_Occurred()) SWIG_fail;
20495 }
20496 {
20497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20498 }
20499 return resultobj;
20500 fail:
20501 return NULL;
20502 }
20503
20504
20505 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
20506 PyObject *obj;
20507 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20508 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
20509 Py_INCREF(obj);
20510 return Py_BuildValue((char *)"");
20511 }
20512 static PyMethodDef SwigMethods[] = {
20513 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20514 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20515 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20516 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20517 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
20518 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
20519 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20520 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
20521 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20522 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20523 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
20524 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
20525 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
20526 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20527 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20528 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20529 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20530 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20531 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20532 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20533 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20534 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20535 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
20536 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20537 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20538 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20539 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20540 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
20541 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20542 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
20543 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20544 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20545 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20546 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20547 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20548 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20549 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20550 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20551 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20552 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20553 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20554 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20555 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20556 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20557 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20558 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20559 { (char *)"Pen_GetDashCount", (PyCFunction) _wrap_Pen_GetDashCount, METH_VARARGS | METH_KEYWORDS, NULL},
20560 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20561 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20562 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
20563 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20564 { (char *)"new_BrushFromBitmap", (PyCFunction) _wrap_new_BrushFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20565 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20566 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20567 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20568 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20569 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20570 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20571 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20572 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
20573 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20574 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
20575 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20576 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20577 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20578 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20579 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20580 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20581 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
20582 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20583 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20584 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20585 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20586 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20587 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
20588 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20589 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20590 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
20591 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20592 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
20593 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
20594 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
20595 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20596 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20597 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20598 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20599 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20600 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20601 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20602 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
20603 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
20604 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
20605 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20606 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20607 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20608 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20609 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20610 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20611 { (char *)"Icon_LoadFile", (PyCFunction) _wrap_Icon_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
20612 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20613 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20614 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20615 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20616 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20617 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20618 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20619 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20620 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
20621 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20622 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20623 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20624 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20625 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20626 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20627 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20628 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
20629 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20630 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20631 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20632 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20633 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20634 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20635 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20636 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
20637 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20638 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20639 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20640 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20641 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20642 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
20643 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20644 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20645 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20646 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
20647 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20648 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
20649 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
20650 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
20651 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20652 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
20653 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
20654 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
20655 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
20656 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
20657 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20658 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
20659 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
20660 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
20661 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20662 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
20663 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
20664 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20665 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
20666 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
20667 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20668 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20669 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20670 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20671 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
20672 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20673 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20674 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
20675 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
20676 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
20677 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20678 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
20679 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20680 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
20681 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
20682 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
20683 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
20684 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
20685 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
20686 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20687 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20688 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
20689 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
20690 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20691 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20692 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20693 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20694 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20695 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20696 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20697 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20698 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20699 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20700 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20701 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20702 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20703 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20704 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20705 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20706 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
20707 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20708 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20709 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
20710 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
20711 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
20712 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
20713 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
20714 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20715 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20716 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20717 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20718 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
20719 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20720 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20721 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20722 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20723 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20724 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20725 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20726 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
20727 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20728 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
20729 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
20730 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20731 { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
20732 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20733 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20734 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20735 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
20736 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
20737 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
20738 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
20739 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20740 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20741 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20742 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
20743 { (char *)"new_Font2", (PyCFunction) _wrap_new_Font2, METH_VARARGS | METH_KEYWORDS, NULL},
20744 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20745 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20746 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20747 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20748 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20749 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20750 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
20751 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20752 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20753 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20754 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20755 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20756 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20757 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20758 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20759 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20760 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20761 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20762 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20763 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20764 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20765 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20766 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20767 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20768 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20769 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20770 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
20771 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20772 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
20773 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
20774 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
20775 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20776 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20777 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20778 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20779 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
20780 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
20781 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
20782 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20783 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
20784 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
20785 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
20786 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
20787 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
20788 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
20789 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
20790 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
20791 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
20792 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
20793 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
20794 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
20795 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
20796 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
20797 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
20798 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
20799 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20800 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20801 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
20802 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20803 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
20804 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20805 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
20806 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
20807 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
20808 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
20809 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
20810 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20811 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
20812 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20813 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20814 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
20815 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
20816 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
20817 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
20818 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
20819 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
20820 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
20821 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
20822 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
20823 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
20824 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
20825 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
20826 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
20827 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
20828 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
20829 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
20830 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
20831 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20832 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20833 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20834 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
20835 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
20836 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
20837 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20838 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
20839 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20840 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
20841 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
20842 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
20843 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20844 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20845 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20846 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20847 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
20848 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20849 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20850 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
20851 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20852 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
20853 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
20854 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
20855 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
20856 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20857 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20858 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20859 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20860 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20861 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
20862 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20863 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
20864 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20865 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
20866 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20867 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20868 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20869 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20870 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
20871 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
20872 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
20873 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
20874 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
20875 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
20876 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
20877 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
20878 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
20879 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
20880 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
20881 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20882 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
20883 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20884 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20885 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
20886 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
20887 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20888 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20889 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
20890 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20891 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20892 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20893 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20894 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20895 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
20896 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20897 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20898 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
20899 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20900 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
20901 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
20902 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
20903 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
20904 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
20905 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
20906 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
20907 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
20908 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20909 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20910 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20911 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
20912 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20913 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
20914 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20915 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20916 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20917 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
20918 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20919 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20920 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20921 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20922 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
20923 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
20924 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
20925 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
20926 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
20927 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
20928 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20929 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20930 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20931 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20932 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20933 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20934 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20935 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20936 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20937 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
20938 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
20939 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20940 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20941 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20942 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20943 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
20944 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
20945 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
20946 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
20947 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20948 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
20949 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
20950 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
20951 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
20952 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
20953 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
20954 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
20955 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
20956 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
20957 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
20958 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
20959 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
20960 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
20961 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
20962 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
20963 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
20964 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
20965 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
20966 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
20967 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
20968 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
20969 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
20970 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
20971 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
20972 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
20973 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
20974 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
20975 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
20976 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
20977 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
20978 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
20979 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
20980 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
20981 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
20982 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
20983 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
20984 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
20985 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
20986 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
20987 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
20988 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
20989 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
20990 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
20991 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
20992 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
20993 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
20994 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20995 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20996 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20997 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
20998 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
20999 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
21000 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
21001 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
21002 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21003 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
21004 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
21005 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
21006 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
21007 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21008 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
21009 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21010 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21011 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21012 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21013 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
21014 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21015 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21016 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
21017 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
21018 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
21019 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
21020 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
21021 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
21022 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
21023 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
21024 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21025 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
21026 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
21027 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21028 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21029 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21030 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21031 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21032 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21033 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21034 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21035 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21036 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21037 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21038 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
21039 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21040 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
21041 { NULL, NULL, 0, NULL }
21042 };
21043
21044
21045 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21046
21047 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
21048 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
21049 }
21050 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
21051 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
21052 }
21053 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
21054 return (void *)((wxGDIObject *) ((wxIcon *) x));
21055 }
21056 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
21057 return (void *)((wxGDIObject *) ((wxPalette *) x));
21058 }
21059 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
21060 return (void *)((wxGDIObject *) ((wxPen *) x));
21061 }
21062 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
21063 return (void *)((wxGDIObject *) ((wxFont *) x));
21064 }
21065 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
21066 return (void *)((wxGDIObject *) ((wxCursor *) x));
21067 }
21068 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
21069 return (void *)((wxGDIObject *) ((wxBitmap *) x));
21070 }
21071 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
21072 return (void *)((wxGDIObject *) ((wxRegion *) x));
21073 }
21074 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
21075 return (void *)((wxGDIObject *) ((wxBrush *) x));
21076 }
21077 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
21078 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
21079 }
21080 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
21081 return (void *)((wxDC *) ((wxScreenDC *) x));
21082 }
21083 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
21084 return (void *)((wxDC *) ((wxMirrorDC *) x));
21085 }
21086 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
21087 return (void *)((wxDC *) ((wxMemoryDC *) x));
21088 }
21089 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
21090 return (void *)((wxDC *) ((wxWindowDC *) x));
21091 }
21092 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
21093 return (void *)((wxDC *) ((wxMetaFileDC *) x));
21094 }
21095 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
21096 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21097 }
21098 static void *_p_wxClientDCTo_p_wxDC(void *x) {
21099 return (void *)((wxDC *) ((wxClientDC *) x));
21100 }
21101 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
21102 return (void *)((wxDC *) ((wxPaintDC *) x));
21103 }
21104 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
21105 return (void *)((wxDC *) ((wxPostScriptDC *) x));
21106 }
21107 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
21108 return (void *)((wxDC *) ((wxPrinterDC *) x));
21109 }
21110 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
21111 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
21112 }
21113 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21114 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21115 }
21116 static void *_p_wxPenTo_p_wxObject(void *x) {
21117 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
21118 }
21119 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
21120 return (void *)((wxObject *) ((wxRegionIterator *) x));
21121 }
21122 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21123 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21124 }
21125 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21126 return (void *)((wxObject *) ((wxSizerItem *) x));
21127 }
21128 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
21129 return (void *)((wxObject *) ((wxColourDatabase *) x));
21130 }
21131 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21132 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21133 }
21134 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21135 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21136 }
21137 static void *_p_wxIconTo_p_wxObject(void *x) {
21138 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
21139 }
21140 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21141 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21142 }
21143 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21144 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21145 }
21146 static void *_p_wxSizerTo_p_wxObject(void *x) {
21147 return (void *)((wxObject *) ((wxSizer *) x));
21148 }
21149 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21150 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21151 }
21152 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21153 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21154 }
21155 static void *_p_wxPenListTo_p_wxObject(void *x) {
21156 return (void *)((wxObject *) ((wxPenList *) x));
21157 }
21158 static void *_p_wxEventTo_p_wxObject(void *x) {
21159 return (void *)((wxObject *) ((wxEvent *) x));
21160 }
21161 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21162 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21163 }
21164 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21165 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21166 }
21167 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21168 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21169 }
21170 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21171 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21172 }
21173 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21174 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21175 }
21176 static void *_p_wxDCTo_p_wxObject(void *x) {
21177 return (void *)((wxObject *) ((wxDC *) x));
21178 }
21179 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21180 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21181 }
21182 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21183 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21184 }
21185 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21186 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21187 }
21188 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21189 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21190 }
21191 static void *_p_wxControlTo_p_wxObject(void *x) {
21192 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21193 }
21194 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21195 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21196 }
21197 static void *_p_wxClientDCTo_p_wxObject(void *x) {
21198 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
21199 }
21200 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21201 return (void *)((wxObject *) ((wxFSFile *) x));
21202 }
21203 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
21204 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
21205 }
21206 static void *_p_wxRegionTo_p_wxObject(void *x) {
21207 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
21208 }
21209 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21210 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21211 }
21212 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
21213 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
21214 }
21215 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
21216 return (void *)((wxObject *) ((wxGDIObject *) x));
21217 }
21218 static void *_p_wxEffectsTo_p_wxObject(void *x) {
21219 return (void *)((wxObject *) ((wxEffects *) x));
21220 }
21221 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21222 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21223 }
21224 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21225 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21226 }
21227 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
21228 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
21229 }
21230 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21231 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21232 }
21233 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21234 return (void *)((wxObject *) ((wxMenuItem *) x));
21235 }
21236 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21237 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21238 }
21239 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21240 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21241 }
21242 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21243 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21244 }
21245 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21246 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21247 }
21248 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21249 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21250 }
21251 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21252 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21253 }
21254 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21255 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21256 }
21257 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21258 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21259 }
21260 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21261 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21262 }
21263 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21264 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21265 }
21266 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21267 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21268 }
21269 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21270 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21271 }
21272 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21273 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21274 }
21275 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21276 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21277 }
21278 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21279 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21280 }
21281 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21282 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21283 }
21284 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21285 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21286 }
21287 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21288 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21289 }
21290 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21291 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21292 }
21293 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21294 return (void *)((wxObject *) ((wxImageHandler *) x));
21295 }
21296 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21297 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21298 }
21299 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21300 return (void *)((wxObject *) ((wxEvtHandler *) x));
21301 }
21302 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
21303 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21304 }
21305 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
21306 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
21307 }
21308 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
21309 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
21310 }
21311 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
21312 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
21313 }
21314 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21315 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21316 }
21317 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21318 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21319 }
21320 static void *_p_wxImageTo_p_wxObject(void *x) {
21321 return (void *)((wxObject *) ((wxImage *) x));
21322 }
21323 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21324 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21325 }
21326 static void *_p_wxPaletteTo_p_wxObject(void *x) {
21327 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
21328 }
21329 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
21330 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
21331 }
21332 static void *_p_wxImageListTo_p_wxObject(void *x) {
21333 return (void *)((wxObject *) ((wxImageList *) x));
21334 }
21335 static void *_p_wxCursorTo_p_wxObject(void *x) {
21336 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
21337 }
21338 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
21339 return (void *)((wxObject *) ((wxEncodingConverter *) x));
21340 }
21341 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
21342 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
21343 }
21344 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21345 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21346 }
21347 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21348 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21349 }
21350 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21351 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21352 }
21353 static void *_p_wxWindowTo_p_wxObject(void *x) {
21354 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21355 }
21356 static void *_p_wxMenuTo_p_wxObject(void *x) {
21357 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21358 }
21359 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21360 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21361 }
21362 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
21363 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
21364 }
21365 static void *_p_wxBrushListTo_p_wxObject(void *x) {
21366 return (void *)((wxObject *) ((wxBrushList *) x));
21367 }
21368 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21369 return (void *)((wxObject *) ((wxFileSystem *) x));
21370 }
21371 static void *_p_wxBitmapTo_p_wxObject(void *x) {
21372 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
21373 }
21374 static void *_p_wxMaskTo_p_wxObject(void *x) {
21375 return (void *)((wxObject *) ((wxMask *) x));
21376 }
21377 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21378 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21379 }
21380 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21381 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21382 }
21383 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21384 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21385 }
21386 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21387 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21388 }
21389 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21390 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21391 }
21392 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21393 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21394 }
21395 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21396 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21397 }
21398 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21399 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21400 }
21401 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21402 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21403 }
21404 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21405 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21406 }
21407 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21408 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21409 }
21410 static void *_p_wxFontTo_p_wxObject(void *x) {
21411 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
21412 }
21413 static void *_p_wxBrushTo_p_wxObject(void *x) {
21414 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
21415 }
21416 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
21417 return (void *)((wxObject *) ((wxMetaFile *) x));
21418 }
21419 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21420 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21421 }
21422 static void *_p_wxColourTo_p_wxObject(void *x) {
21423 return (void *)((wxObject *) ((wxColour *) x));
21424 }
21425 static void *_p_wxFontListTo_p_wxObject(void *x) {
21426 return (void *)((wxObject *) ((wxFontList *) x));
21427 }
21428 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21429 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21430 }
21431 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21432 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21433 }
21434 static void *_p_wxControlTo_p_wxWindow(void *x) {
21435 return (void *)((wxWindow *) ((wxControl *) x));
21436 }
21437 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21438 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21439 }
21440 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
21441 return (void *)((wxWindow *) ((wxMenuBar *) x));
21442 }
21443 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}};
21444 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}};
21445 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}};
21446 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}};
21447 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}};
21448 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}};
21449 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}};
21450 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}};
21451 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}};
21452 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}};
21453 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}};
21454 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}};
21455 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}};
21456 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}};
21457 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}};
21458 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}};
21459 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}};
21460 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}};
21461 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}};
21462 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}};
21463 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}};
21464 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}};
21465 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}};
21466 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxRegionIterator", _p_wxRegionIteratorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPen", _p_wxPenTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColourDatabase", _p_wxColourDatabaseTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPenList", _p_wxPenListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMask", _p_wxMaskTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFont", _p_wxFontTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClientDC", _p_wxClientDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMemoryDC", _p_wxMemoryDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxRegion", _p_wxRegionTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDC", _p_wxDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIcon", _p_wxIconTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDC", _p_wxWindowDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGDIObject", _p_wxGDIObjectTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEffects", _p_wxEffectsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPostScriptDC", _p_wxPostScriptDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintDC", _p_wxPaintDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBufferedPaintDC", _p_wxBufferedPaintDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrinterDC", _p_wxPrinterDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScreenDC", _p_wxScreenDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBufferedDC", _p_wxBufferedDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPalette", _p_wxPaletteTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageList", _p_wxImageListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCursor", _p_wxCursorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxMirrorDC", _p_wxMirrorDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEncodingConverter", _p_wxEncodingConverterTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMetaFileDC", _p_wxMetaFileDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBrushList", _p_wxBrushListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBitmap", _p_wxBitmapTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBrush", _p_wxBrushTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMetaFile", _p_wxMetaFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColour", _p_wxColourTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFontList", _p_wxFontListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
21467 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}};
21468 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}};
21469 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}};
21470 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}};
21471 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}};
21472 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}};
21473 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}};
21474 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}};
21475 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}};
21476 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}};
21477 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}};
21478 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}};
21479 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}};
21480 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}};
21481 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}};
21482 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}};
21483 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}};
21484 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}};
21485 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}};
21486 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}};
21487 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}};
21488 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}};
21489 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}};
21490 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}};
21491 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}};
21492 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}};
21493 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}};
21494 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}};
21495 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}};
21496 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}};
21497 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}};
21498 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}};
21499 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}};
21500 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}};
21501 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}};
21502 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}};
21503 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}};
21504 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}};
21505
21506 static swig_type_info *swig_types_initial[] = {
21507 _swigt__p_wxPostScriptDC,
21508 _swigt__p_wxBrush,
21509 _swigt__p_wxColour,
21510 _swigt__p_wxDC,
21511 _swigt__p_wxMirrorDC,
21512 _swigt__p_form_ops_t,
21513 _swigt__p_wxDuplexMode,
21514 _swigt__p_wxPyFontEnumerator,
21515 _swigt__p_char,
21516 _swigt__p_wxIconLocation,
21517 _swigt__p_wxImage,
21518 _swigt__p_wxMetaFileDC,
21519 _swigt__p_wxMask,
21520 _swigt__p_wxSize,
21521 _swigt__p_wxFont,
21522 _swigt__p_wxWindow,
21523 _swigt__p_double,
21524 _swigt__p_wxMemoryDC,
21525 _swigt__p_wxFontMapper,
21526 _swigt__p_wxEffects,
21527 _swigt__p_wxNativeEncodingInfo,
21528 _swigt__p_wxPalette,
21529 _swigt__p_wxBitmap,
21530 _swigt__p_wxObject,
21531 _swigt__p_wxRegionIterator,
21532 _swigt__p_wxRect,
21533 _swigt__p_wxPaperSize,
21534 _swigt__p_wxString,
21535 _swigt__unsigned_int,
21536 _swigt__p_unsigned_int,
21537 _swigt__p_wxPrinterDC,
21538 _swigt__p_wxIconBundle,
21539 _swigt__p_wxPoint,
21540 _swigt__p_wxDash,
21541 _swigt__p_wxScreenDC,
21542 _swigt__p_wxCursor,
21543 _swigt__p_wxClientDC,
21544 _swigt__p_wxBufferedDC,
21545 _swigt__p_wxImageList,
21546 _swigt__p_unsigned_char,
21547 _swigt__p_wxGDIObject,
21548 _swigt__p_wxIcon,
21549 _swigt__p_wxLocale,
21550 _swigt__ptrdiff_t,
21551 _swigt__std__ptrdiff_t,
21552 _swigt__p_wxRegion,
21553 _swigt__p_wxConfigBase,
21554 _swigt__p_wxLanguageInfo,
21555 _swigt__p_wxWindowDC,
21556 _swigt__p_wxPrintData,
21557 _swigt__p_wxBrushList,
21558 _swigt__p_wxFontList,
21559 _swigt__p_wxPen,
21560 _swigt__p_wxBufferedPaintDC,
21561 _swigt__p_wxPaintDC,
21562 _swigt__p_wxPenList,
21563 _swigt__p_int,
21564 _swigt__p_wxMetaFile,
21565 _swigt__p_unsigned_long,
21566 _swigt__p_wxNativeFontInfo,
21567 _swigt__p_wxEncodingConverter,
21568 _swigt__p_wxColourDatabase,
21569 0
21570 };
21571
21572
21573 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
21574
21575 static swig_const_info swig_const_table[] = {
21576 {0, 0, 0, 0.0, 0, 0}};
21577
21578 #ifdef __cplusplus
21579 }
21580 #endif
21581
21582
21583 #ifdef __cplusplus
21584 extern "C" {
21585 #endif
21586
21587 /* Python-specific SWIG API */
21588 #define SWIG_newvarlink() SWIG_Python_newvarlink()
21589 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
21590 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
21591
21592 /* -----------------------------------------------------------------------------
21593 * global variable support code.
21594 * ----------------------------------------------------------------------------- */
21595
21596 typedef struct swig_globalvar {
21597 char *name; /* Name of global variable */
21598 PyObject *(*get_attr)(); /* Return the current value */
21599 int (*set_attr)(PyObject *); /* Set the value */
21600 struct swig_globalvar *next;
21601 } swig_globalvar;
21602
21603 typedef struct swig_varlinkobject {
21604 PyObject_HEAD
21605 swig_globalvar *vars;
21606 } swig_varlinkobject;
21607
21608 static PyObject *
21609 swig_varlink_repr(swig_varlinkobject *v) {
21610 v = v;
21611 return PyString_FromString("<Swig global variables>");
21612 }
21613
21614 static int
21615 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
21616 swig_globalvar *var;
21617 flags = flags;
21618 fprintf(fp,"Swig global variables { ");
21619 for (var = v->vars; var; var=var->next) {
21620 fprintf(fp,"%s", var->name);
21621 if (var->next) fprintf(fp,", ");
21622 }
21623 fprintf(fp," }\n");
21624 return 0;
21625 }
21626
21627 static PyObject *
21628 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
21629 swig_globalvar *var = v->vars;
21630 while (var) {
21631 if (strcmp(var->name,n) == 0) {
21632 return (*var->get_attr)();
21633 }
21634 var = var->next;
21635 }
21636 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21637 return NULL;
21638 }
21639
21640 static int
21641 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
21642 swig_globalvar *var = v->vars;
21643 while (var) {
21644 if (strcmp(var->name,n) == 0) {
21645 return (*var->set_attr)(p);
21646 }
21647 var = var->next;
21648 }
21649 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21650 return 1;
21651 }
21652
21653 static PyTypeObject varlinktype = {
21654 PyObject_HEAD_INIT(0)
21655 0, /* Number of items in variable part (ob_size) */
21656 (char *)"swigvarlink", /* Type name (tp_name) */
21657 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
21658 0, /* Itemsize (tp_itemsize) */
21659 0, /* Deallocator (tp_dealloc) */
21660 (printfunc) swig_varlink_print, /* Print (tp_print) */
21661 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
21662 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
21663 0, /* tp_compare */
21664 (reprfunc) swig_varlink_repr, /* tp_repr */
21665 0, /* tp_as_number */
21666 0, /* tp_as_sequence */
21667 0, /* tp_as_mapping */
21668 0, /* tp_hash */
21669 0, /* tp_call */
21670 0, /* tp_str */
21671 0, /* tp_getattro */
21672 0, /* tp_setattro */
21673 0, /* tp_as_buffer */
21674 0, /* tp_flags */
21675 0, /* tp_doc */
21676 #if PY_VERSION_HEX >= 0x02000000
21677 0, /* tp_traverse */
21678 0, /* tp_clear */
21679 #endif
21680 #if PY_VERSION_HEX >= 0x02010000
21681 0, /* tp_richcompare */
21682 0, /* tp_weaklistoffset */
21683 #endif
21684 #if PY_VERSION_HEX >= 0x02020000
21685 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
21686 #endif
21687 #if PY_VERSION_HEX >= 0x02030000
21688 0, /* tp_del */
21689 #endif
21690 #ifdef COUNT_ALLOCS
21691 0,0,0,0 /* tp_alloc -> tp_next */
21692 #endif
21693 };
21694
21695 /* Create a variable linking object for use later */
21696 static PyObject *
21697 SWIG_Python_newvarlink(void) {
21698 swig_varlinkobject *result = 0;
21699 result = PyMem_NEW(swig_varlinkobject,1);
21700 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
21701 result->ob_type = &varlinktype;
21702 result->vars = 0;
21703 result->ob_refcnt = 0;
21704 Py_XINCREF((PyObject *) result);
21705 return ((PyObject*) result);
21706 }
21707
21708 static void
21709 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
21710 swig_varlinkobject *v;
21711 swig_globalvar *gv;
21712 v= (swig_varlinkobject *) p;
21713 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
21714 gv->name = (char *) malloc(strlen(name)+1);
21715 strcpy(gv->name,name);
21716 gv->get_attr = get_attr;
21717 gv->set_attr = set_attr;
21718 gv->next = v->vars;
21719 v->vars = gv;
21720 }
21721
21722 /* -----------------------------------------------------------------------------
21723 * constants/methods manipulation
21724 * ----------------------------------------------------------------------------- */
21725
21726 /* Install Constants */
21727 static void
21728 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
21729 PyObject *obj = 0;
21730 size_t i;
21731 for (i = 0; constants[i].type; i++) {
21732 switch(constants[i].type) {
21733 case SWIG_PY_INT:
21734 obj = PyInt_FromLong(constants[i].lvalue);
21735 break;
21736 case SWIG_PY_FLOAT:
21737 obj = PyFloat_FromDouble(constants[i].dvalue);
21738 break;
21739 case SWIG_PY_STRING:
21740 if (constants[i].pvalue) {
21741 obj = PyString_FromString((char *) constants[i].pvalue);
21742 } else {
21743 Py_INCREF(Py_None);
21744 obj = Py_None;
21745 }
21746 break;
21747 case SWIG_PY_POINTER:
21748 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
21749 break;
21750 case SWIG_PY_BINARY:
21751 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
21752 break;
21753 default:
21754 obj = 0;
21755 break;
21756 }
21757 if (obj) {
21758 PyDict_SetItemString(d,constants[i].name,obj);
21759 Py_DECREF(obj);
21760 }
21761 }
21762 }
21763
21764 /* -----------------------------------------------------------------------------*/
21765 /* Fix SwigMethods to carry the callback ptrs when needed */
21766 /* -----------------------------------------------------------------------------*/
21767
21768 static void
21769 SWIG_Python_FixMethods(PyMethodDef *methods,
21770 swig_const_info *const_table,
21771 swig_type_info **types,
21772 swig_type_info **types_initial) {
21773 size_t i;
21774 for (i = 0; methods[i].ml_name; ++i) {
21775 char *c = methods[i].ml_doc;
21776 if (c && (c = strstr(c, "swig_ptr: "))) {
21777 int j;
21778 swig_const_info *ci = 0;
21779 char *name = c + 10;
21780 for (j = 0; const_table[j].type; j++) {
21781 if (strncmp(const_table[j].name, name,
21782 strlen(const_table[j].name)) == 0) {
21783 ci = &(const_table[j]);
21784 break;
21785 }
21786 }
21787 if (ci) {
21788 size_t shift = (ci->ptype) - types;
21789 swig_type_info *ty = types_initial[shift];
21790 size_t ldoc = (c - methods[i].ml_doc);
21791 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
21792 char *ndoc = (char*)malloc(ldoc + lptr + 10);
21793 char *buff = ndoc;
21794 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
21795 strncpy(buff, methods[i].ml_doc, ldoc);
21796 buff += ldoc;
21797 strncpy(buff, "swig_ptr: ", 10);
21798 buff += 10;
21799 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
21800 methods[i].ml_doc = ndoc;
21801 }
21802 }
21803 }
21804 }
21805
21806 /* -----------------------------------------------------------------------------*
21807 * Initialize type list
21808 * -----------------------------------------------------------------------------*/
21809
21810 #if PY_MAJOR_VERSION < 2
21811 /* PyModule_AddObject function was introduced in Python 2.0. The following function
21812 is copied out of Python/modsupport.c in python version 2.3.4 */
21813 static int
21814 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
21815 {
21816 PyObject *dict;
21817 if (!PyModule_Check(m)) {
21818 PyErr_SetString(PyExc_TypeError,
21819 "PyModule_AddObject() needs module as first arg");
21820 return -1;
21821 }
21822 if (!o) {
21823 PyErr_SetString(PyExc_TypeError,
21824 "PyModule_AddObject() needs non-NULL value");
21825 return -1;
21826 }
21827
21828 dict = PyModule_GetDict(m);
21829 if (dict == NULL) {
21830 /* Internal error -- modules must have a dict! */
21831 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
21832 PyModule_GetName(m));
21833 return -1;
21834 }
21835 if (PyDict_SetItemString(dict, name, o))
21836 return -1;
21837 Py_DECREF(o);
21838 return 0;
21839 }
21840 #endif
21841
21842 static swig_type_info **
21843 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
21844 static PyMethodDef swig_empty_runtime_method_table[] = {
21845 {
21846 NULL, NULL, 0, NULL
21847 }
21848 };/* Sentinel */
21849
21850 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
21851 swig_empty_runtime_method_table);
21852 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
21853 if (pointer && module) {
21854 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
21855 }
21856 return type_list_handle;
21857 }
21858
21859 static swig_type_info **
21860 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
21861 swig_type_info **type_pointer;
21862
21863 /* first check if module already created */
21864 type_pointer = SWIG_Python_GetTypeListHandle();
21865 if (type_pointer) {
21866 return type_pointer;
21867 } else {
21868 /* create a new module and variable */
21869 return SWIG_Python_SetTypeListHandle(type_list_handle);
21870 }
21871 }
21872
21873 #ifdef __cplusplus
21874 }
21875 #endif
21876
21877 /* -----------------------------------------------------------------------------*
21878 * Partial Init method
21879 * -----------------------------------------------------------------------------*/
21880
21881 #ifdef SWIG_LINK_RUNTIME
21882 #ifdef __cplusplus
21883 extern "C"
21884 #endif
21885 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
21886 #endif
21887
21888 #ifdef __cplusplus
21889 extern "C"
21890 #endif
21891 SWIGEXPORT(void) SWIG_init(void) {
21892 static PyObject *SWIG_globals = 0;
21893 static int typeinit = 0;
21894 PyObject *m, *d;
21895 int i;
21896 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
21897
21898 /* Fix SwigMethods to carry the callback ptrs when needed */
21899 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
21900
21901 m = Py_InitModule((char *) SWIG_name, SwigMethods);
21902 d = PyModule_GetDict(m);
21903
21904 if (!typeinit) {
21905 #ifdef SWIG_LINK_RUNTIME
21906 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
21907 #else
21908 # ifndef SWIG_STATIC_RUNTIME
21909 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
21910 # endif
21911 #endif
21912 for (i = 0; swig_types_initial[i]; i++) {
21913 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
21914 }
21915 typeinit = 1;
21916 }
21917 SWIG_InstallConstants(d,swig_const_table);
21918
21919 {
21920 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
21921 }
21922 {
21923 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
21924 }
21925 {
21926 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
21927 }
21928 {
21929 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
21930 }
21931 {
21932 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
21933 }
21934 {
21935 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
21936 }
21937 {
21938 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
21939 }
21940 {
21941 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
21942 }
21943 {
21944 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
21945 }
21946 {
21947 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
21948 }
21949 {
21950 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
21951 }
21952 {
21953 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
21954 }
21955 {
21956 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
21957 }
21958 {
21959 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
21960 }
21961 {
21962 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
21963 }
21964 {
21965 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
21966 }
21967 {
21968 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
21969 }
21970 {
21971 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
21972 }
21973 {
21974 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
21975 }
21976 {
21977 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
21978 }
21979 {
21980 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
21981 }
21982 {
21983 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
21984 }
21985 {
21986 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
21987 }
21988 {
21989 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
21990 }
21991 {
21992 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
21993 }
21994 {
21995 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
21996 }
21997 {
21998 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
21999 }
22000 {
22001 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
22002 }
22003 {
22004 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
22005 }
22006 {
22007 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
22008 }
22009 {
22010 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
22011 }
22012 {
22013 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
22014 }
22015 {
22016 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
22017 }
22018 {
22019 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
22020 }
22021 {
22022 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
22023 }
22024 {
22025 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
22026 }
22027 {
22028 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
22029 }
22030 {
22031 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
22032 }
22033 {
22034 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
22035 }
22036 {
22037 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
22038 }
22039 {
22040 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
22041 }
22042 {
22043 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
22044 }
22045 {
22046 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
22047 }
22048 {
22049 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
22050 }
22051 {
22052 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
22053 }
22054 {
22055 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
22056 }
22057 {
22058 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
22059 }
22060 {
22061 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
22062 }
22063 {
22064 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
22065 }
22066 {
22067 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
22068 }
22069 {
22070 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
22071 }
22072 {
22073 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
22074 }
22075 {
22076 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
22077 }
22078 {
22079 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
22080 }
22081 {
22082 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
22083 }
22084 {
22085 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
22086 }
22087 {
22088 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
22089 }
22090 {
22091 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
22092 }
22093 {
22094 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
22095 }
22096 {
22097 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
22098 }
22099 {
22100 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
22101 }
22102 {
22103 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
22104 }
22105 {
22106 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
22107 }
22108 {
22109 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
22110 }
22111 {
22112 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
22113 }
22114 {
22115 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
22116 }
22117 {
22118 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
22119 }
22120 {
22121 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
22122 }
22123 {
22124 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
22125 }
22126 {
22127 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
22128 }
22129 {
22130 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
22131 }
22132 {
22133 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
22134 }
22135 {
22136 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
22137 }
22138 {
22139 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
22140 }
22141 {
22142 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
22143 }
22144 {
22145 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
22146 }
22147 {
22148 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
22149 }
22150 {
22151 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
22152 }
22153 {
22154 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
22155 }
22156 {
22157 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
22158 }
22159 {
22160 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
22161 }
22162 {
22163 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
22164 }
22165 {
22166 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
22167 }
22168 {
22169 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
22170 }
22171 {
22172 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
22173 }
22174 {
22175 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
22176 }
22177 {
22178 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
22179 }
22180 {
22181 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
22182 }
22183 {
22184 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
22185 }
22186 {
22187 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
22188 }
22189 {
22190 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
22191 }
22192 {
22193 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
22194 }
22195 {
22196 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
22197 }
22198 {
22199 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
22200 }
22201 {
22202 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
22203 }
22204 {
22205 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
22206 }
22207 {
22208 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
22209 }
22210 {
22211 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
22212 }
22213 {
22214 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
22215 }
22216 {
22217 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
22218 }
22219 {
22220 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
22221 }
22222 {
22223 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
22224 }
22225 {
22226 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
22227 }
22228 {
22229 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
22230 }
22231 {
22232 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
22233 }
22234 {
22235 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
22236 }
22237 {
22238 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
22239 }
22240 {
22241 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
22242 }
22243 {
22244 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
22245 }
22246 {
22247 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
22248 }
22249 {
22250 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
22251 }
22252 {
22253 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
22254 }
22255 {
22256 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
22257 }
22258 {
22259 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
22260 }
22261 {
22262 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
22263 }
22264 {
22265 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
22266 }
22267 {
22268 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
22269 }
22270 {
22271 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
22272 }
22273 {
22274 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
22275 }
22276 {
22277 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
22278 }
22279 {
22280 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
22281 }
22282 {
22283 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
22284 }
22285 {
22286 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
22287 }
22288 {
22289 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
22290 }
22291 {
22292 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
22293 }
22294 {
22295 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
22296 }
22297 {
22298 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
22299 }
22300
22301 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
22302
22303 {
22304 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
22305 }
22306 {
22307 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
22308 }
22309 {
22310 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
22311 }
22312 {
22313 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
22314 }
22315 {
22316 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
22317 }
22318 {
22319 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
22320 }
22321 {
22322 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
22323 }
22324 {
22325 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
22326 }
22327 {
22328 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
22329 }
22330 {
22331 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
22332 }
22333 {
22334 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
22335 }
22336 {
22337 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
22338 }
22339 {
22340 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
22341 }
22342 {
22343 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
22344 }
22345 {
22346 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
22347 }
22348 {
22349 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
22350 }
22351 {
22352 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
22353 }
22354 {
22355 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
22356 }
22357 {
22358 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
22359 }
22360 {
22361 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
22362 }
22363 {
22364 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
22365 }
22366 {
22367 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
22368 }
22369 {
22370 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
22371 }
22372 {
22373 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
22374 }
22375 {
22376 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
22377 }
22378 {
22379 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
22380 }
22381 {
22382 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
22383 }
22384 {
22385 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
22386 }
22387 {
22388 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
22389 }
22390 {
22391 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
22392 }
22393 {
22394 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
22395 }
22396 {
22397 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
22398 }
22399 {
22400 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
22401 }
22402 {
22403 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
22404 }
22405 {
22406 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
22407 }
22408 {
22409 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
22410 }
22411 {
22412 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
22413 }
22414 {
22415 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
22416 }
22417 {
22418 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
22419 }
22420 {
22421 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
22422 }
22423 {
22424 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
22425 }
22426 {
22427 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
22428 }
22429 {
22430 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
22431 }
22432 {
22433 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
22434 }
22435 {
22436 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
22437 }
22438 {
22439 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
22440 }
22441 {
22442 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
22443 }
22444 {
22445 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
22446 }
22447 {
22448 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
22449 }
22450 {
22451 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
22452 }
22453 {
22454 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
22455 }
22456 {
22457 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
22458 }
22459 {
22460 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
22461 }
22462 {
22463 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
22464 }
22465 {
22466 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
22467 }
22468 {
22469 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
22470 }
22471 {
22472 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
22473 }
22474 {
22475 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
22476 }
22477 {
22478 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
22479 }
22480 {
22481 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
22482 }
22483 {
22484 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
22485 }
22486 {
22487 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
22488 }
22489 {
22490 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
22491 }
22492 {
22493 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
22494 }
22495 {
22496 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
22497 }
22498 {
22499 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
22500 }
22501 {
22502 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
22503 }
22504 {
22505 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
22506 }
22507 {
22508 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
22509 }
22510 {
22511 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
22512 }
22513 {
22514 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
22515 }
22516 {
22517 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
22518 }
22519 {
22520 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
22521 }
22522 {
22523 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
22524 }
22525 {
22526 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
22527 }
22528 {
22529 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
22530 }
22531 {
22532 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
22533 }
22534 {
22535 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
22536 }
22537 {
22538 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
22539 }
22540 {
22541 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
22542 }
22543 {
22544 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
22545 }
22546 {
22547 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
22548 }
22549 {
22550 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
22551 }
22552 {
22553 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
22554 }
22555 {
22556 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
22557 }
22558 {
22559 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
22560 }
22561 {
22562 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
22563 }
22564 {
22565 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
22566 }
22567 {
22568 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
22569 }
22570 {
22571 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
22572 }
22573 {
22574 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
22575 }
22576 {
22577 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
22578 }
22579 {
22580 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
22581 }
22582 {
22583 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
22584 }
22585 {
22586 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
22587 }
22588 {
22589 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
22590 }
22591 {
22592 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
22593 }
22594 {
22595 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
22596 }
22597 {
22598 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
22599 }
22600 {
22601 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
22602 }
22603 {
22604 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
22605 }
22606 {
22607 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
22608 }
22609 {
22610 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
22611 }
22612 {
22613 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
22614 }
22615 {
22616 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
22617 }
22618 {
22619 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
22620 }
22621 {
22622 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
22623 }
22624 {
22625 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
22626 }
22627 {
22628 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
22629 }
22630 {
22631 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
22632 }
22633 {
22634 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
22635 }
22636 {
22637 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
22638 }
22639 {
22640 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
22641 }
22642 {
22643 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
22644 }
22645 {
22646 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
22647 }
22648 {
22649 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
22650 }
22651 {
22652 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
22653 }
22654 {
22655 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
22656 }
22657 {
22658 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
22659 }
22660 {
22661 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
22662 }
22663 {
22664 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
22665 }
22666 {
22667 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
22668 }
22669 {
22670 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
22671 }
22672 {
22673 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
22674 }
22675 {
22676 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
22677 }
22678 {
22679 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
22680 }
22681 {
22682 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
22683 }
22684 {
22685 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
22686 }
22687 {
22688 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
22689 }
22690 {
22691 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
22692 }
22693 {
22694 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
22695 }
22696 {
22697 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
22698 }
22699 {
22700 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
22701 }
22702 {
22703 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
22704 }
22705 {
22706 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
22707 }
22708 {
22709 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
22710 }
22711 {
22712 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
22713 }
22714 {
22715 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
22716 }
22717 {
22718 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
22719 }
22720 {
22721 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
22722 }
22723 {
22724 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
22725 }
22726 {
22727 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
22728 }
22729 {
22730 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
22731 }
22732 {
22733 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
22734 }
22735 {
22736 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
22737 }
22738 {
22739 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
22740 }
22741 {
22742 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
22743 }
22744 {
22745 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
22746 }
22747 {
22748 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
22749 }
22750 {
22751 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
22752 }
22753 {
22754 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
22755 }
22756 {
22757 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
22758 }
22759 {
22760 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
22761 }
22762 {
22763 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
22764 }
22765 {
22766 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
22767 }
22768 {
22769 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
22770 }
22771 {
22772 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
22773 }
22774 {
22775 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
22776 }
22777 {
22778 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
22779 }
22780 {
22781 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
22782 }
22783 {
22784 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
22785 }
22786 {
22787 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
22788 }
22789 {
22790 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
22791 }
22792 {
22793 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
22794 }
22795 {
22796 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
22797 }
22798 {
22799 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
22800 }
22801 {
22802 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
22803 }
22804 {
22805 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
22806 }
22807 {
22808 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
22809 }
22810 {
22811 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
22812 }
22813 {
22814 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
22815 }
22816 {
22817 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
22818 }
22819 {
22820 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
22821 }
22822 {
22823 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
22824 }
22825 {
22826 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
22827 }
22828 {
22829 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
22830 }
22831 {
22832 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
22833 }
22834 {
22835 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
22836 }
22837 {
22838 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
22839 }
22840 {
22841 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
22842 }
22843 {
22844 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
22845 }
22846 {
22847 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
22848 }
22849 {
22850 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
22851 }
22852 {
22853 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
22854 }
22855 {
22856 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
22857 }
22858 {
22859 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
22860 }
22861 {
22862 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
22863 }
22864 {
22865 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
22866 }
22867 {
22868 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
22869 }
22870 {
22871 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
22872 }
22873 {
22874 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
22875 }
22876 {
22877 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
22878 }
22879 {
22880 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
22881 }
22882 {
22883 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
22884 }
22885 {
22886 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
22887 }
22888 {
22889 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
22890 }
22891 {
22892 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
22893 }
22894 {
22895 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
22896 }
22897 {
22898 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
22899 }
22900 {
22901 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
22902 }
22903 {
22904 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
22905 }
22906 {
22907 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
22908 }
22909 {
22910 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
22911 }
22912 {
22913 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
22914 }
22915 {
22916 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
22917 }
22918 {
22919 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
22920 }
22921 {
22922 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
22923 }
22924 {
22925 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
22926 }
22927 {
22928 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
22929 }
22930 {
22931 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
22932 }
22933 {
22934 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
22935 }
22936 {
22937 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
22938 }
22939 {
22940 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
22941 }
22942 {
22943 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
22944 }
22945 {
22946 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
22947 }
22948 {
22949 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
22950 }
22951 {
22952 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
22953 }
22954 {
22955 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
22956 }
22957 {
22958 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
22959 }
22960 {
22961 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
22962 }
22963 {
22964 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
22965 }
22966 {
22967 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
22968 }
22969 {
22970 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
22971 }
22972 {
22973 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
22974 }
22975 {
22976 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
22977 }
22978 {
22979 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
22980 }
22981 {
22982 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
22983 }
22984 {
22985 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
22986 }
22987 {
22988 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
22989 }
22990 {
22991 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
22992 }
22993 {
22994 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
22995 }
22996 {
22997 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
22998 }
22999 {
23000 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
23001 }
23002 {
23003 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
23004 }
23005 {
23006 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
23007 }
23008 {
23009 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
23010 }
23011 {
23012 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
23013 }
23014 {
23015 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
23016 }
23017 {
23018 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
23019 }
23020 {
23021 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
23022 }
23023 {
23024 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
23025 }
23026 {
23027 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
23028 }
23029 {
23030 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
23031 }
23032 {
23033 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
23034 }
23035 {
23036 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
23037 }
23038 {
23039 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
23040 }
23041 {
23042 PyDict_SetItemString(d,"BUFFER_VIRTUAL_AREA", SWIG_From_int((int)(wxBUFFER_VIRTUAL_AREA)));
23043 }
23044 {
23045 PyDict_SetItemString(d,"BUFFER_CLIENT_AREA", SWIG_From_int((int)(wxBUFFER_CLIENT_AREA)));
23046 }
23047 {
23048 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
23049 }
23050 {
23051 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
23052 }
23053 {
23054 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
23055 }
23056 {
23057 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
23058 }
23059 {
23060 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
23061 }
23062 {
23063 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
23064 }
23065 {
23066 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
23067 }
23068 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
23069 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
23070 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
23071 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
23072 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
23073 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
23074 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
23075 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
23076 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
23077 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
23078 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
23079 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
23080 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
23081 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
23082 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
23083 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
23084 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
23085 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
23086 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
23087 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
23088 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
23089 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
23090 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
23091 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
23092 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
23093 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
23094 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
23095 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
23096 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
23097 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
23098 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
23099 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
23100 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
23101 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
23102 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
23103 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
23104 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
23105 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
23106 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
23107 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
23108 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
23109 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
23110 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
23111 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
23112 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
23113 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
23114 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
23115
23116 // Work around a chicken/egg problem in drawlist.cpp
23117 wxPyDrawList_SetAPIPtr();
23118
23119 }
23120
wxWidgets (Impactor)